bfd/elf32-nds32.c

   1 /* NDS32-specific support for 32-bit ELF.
   2    Copyright (C) 2012-2020 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 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1.  */
  36 #define OCTETS_PER_BYTE(ABFD, SEC) 1
  37
  38 /* Relocation HOWTO functions.  */
  39 static bfd_reloc_status_type nds32_elf_ignore_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type nds32_elf_hi20_reloc
  44   (bfd *, arelent *, asymbol *, void *,
  45    asection *, bfd *, char **);
  46 static bfd_reloc_status_type nds32_elf_lo12_reloc
  47   (bfd *, arelent *, asymbol *, void *,
  48    asection *, bfd *, char **);
  49 static bfd_reloc_status_type nds32_elf_generic_reloc
  50   (bfd *, arelent *, asymbol *, void *,
  51    asection *, bfd *, char **);
  52 static bfd_reloc_status_type nds32_elf_sda15_reloc
  53   (bfd *, arelent *, asymbol *, void *,
  54    asection *, bfd *, char **);
  55
  56 /* Helper functions for HOWTO.  */
  57 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
  58   (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
  59    asection *, bfd_vma, bfd_vma);
  60
  61 /* Nds32 helper functions.  */
  62 static bfd_vma calculate_memory_address
  63   (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
  64 static int nds32_get_section_contents (bfd *, asection *,
  65                                        bfd_byte **, bfd_boolean);
  66 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
  67                                  Elf_Internal_Sym **);
  68 static bfd_boolean  nds32_relax_fp_as_gp
  69   (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
  70    Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
  71    Elf_Internal_Sym *isymbuf);
  72 static bfd_boolean nds32_fag_remove_unused_fpbase
  73   (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
  74    Elf_Internal_Rela *irelend);
  75
  76 enum
  77 {
  78   MACH_V1 = bfd_mach_n1h,
  79   MACH_V2 = bfd_mach_n1h_v2,
  80   MACH_V3 = bfd_mach_n1h_v3,
  81   MACH_V3M = bfd_mach_n1h_v3m
  82 };
  83
  84 #define MIN(a, b) ((a) > (b) ? (b) : (a))
  85 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  86
  87 /* The name of the dynamic interpreter.  This is put in the .interp
  88    section.  */
  89 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  90
  91 #define NDS32_GUARD_SEC_P(flags) ((flags) & SEC_ALLOC \
  92                                   && (flags) & SEC_LOAD \
  93                                   && (flags) & SEC_READONLY)
  94
  95 /* The nop opcode we use.  */
  96 #define NDS32_NOP32 0x40000009
  97 #define NDS32_NOP16 0x9200
  98
  99 /* The size in bytes of an entry in the procedure linkage table.  */
 100 #define PLT_ENTRY_SIZE 24
 101 #define PLT_HEADER_SIZE 24
 102
 103 /* The first entry in a procedure linkage table are reserved,
 104    and the initial contents are unimportant (we zero them out).
 105    Subsequent entries look like this.  */
 106 #define PLT0_ENTRY_WORD0  0x46f00000            /* sethi   r15, HI20(.got+4)      */
 107 #define PLT0_ENTRY_WORD1  0x58f78000            /* ori     r15, r25, LO12(.got+4) */
 108 #define PLT0_ENTRY_WORD2  0x05178000            /* lwi     r17, [r15+0]           */
 109 #define PLT0_ENTRY_WORD3  0x04f78001            /* lwi     r15, [r15+4]           */
 110 #define PLT0_ENTRY_WORD4  0x4a003c00            /* jr      r15                    */
 111
 112 /* $ta is change to $r15 (from $r25).  */
 113 #define PLT0_PIC_ENTRY_WORD0  0x46f00000        /* sethi   r15, HI20(got[1]@GOT)  */
 114 #define PLT0_PIC_ENTRY_WORD1  0x58f78000        /* ori     r15, r15, LO12(got[1]@GOT) */
 115 #define PLT0_PIC_ENTRY_WORD2  0x40f7f400        /* add     r15, gp, r15           */
 116 #define PLT0_PIC_ENTRY_WORD3  0x05178000        /* lwi     r17, [r15+0]           */
 117 #define PLT0_PIC_ENTRY_WORD4  0x04f78001        /* lwi     r15, [r15+4]           */
 118 #define PLT0_PIC_ENTRY_WORD5  0x4a003c00        /* jr      r15                    */
 119
 120 #define PLT_ENTRY_WORD0  0x46f00000             /* sethi   r15, HI20(&got[n+3])      */
 121 #define PLT_ENTRY_WORD1  0x04f78000             /* lwi     r15, r15, LO12(&got[n+3]) */
 122 #define PLT_ENTRY_WORD2  0x4a003c00             /* jr      r15                       */
 123 #define PLT_ENTRY_WORD3  0x45000000             /* movi    r16, sizeof(RELA) * n     */
 124 #define PLT_ENTRY_WORD4  0x48000000             /* j      .plt0.                     */
 125
 126 #define PLT_PIC_ENTRY_WORD0  0x46f00000         /* sethi  r15, HI20(got[n+3]@GOT)    */
 127 #define PLT_PIC_ENTRY_WORD1  0x58f78000         /* ori    r15, r15,    LO12(got[n+3]@GOT) */
 128 #define PLT_PIC_ENTRY_WORD2  0x38febc02         /* lw     r15, [gp+r15]              */
 129 #define PLT_PIC_ENTRY_WORD3  0x4a003c00         /* jr     r15                        */
 130 #define PLT_PIC_ENTRY_WORD4  0x45000000         /* movi   r16, sizeof(RELA) * n      */
 131 #define PLT_PIC_ENTRY_WORD5  0x48000000         /* j      .plt0                      */
 132
 133 /* These are macros used to get the relocation accurate value.  */
 134 #define ACCURATE_8BIT_S1        (0x100)
 135 #define ACCURATE_U9BIT_S1       (0x400)
 136 #define ACCURATE_12BIT_S1       (0x2000)
 137 #define ACCURATE_14BIT_S1       (0x4000)
 138 #define ACCURATE_19BIT          (0x40000)
 139
 140 /* These are macros used to get the relocation conservative value.  */
 141 #define CONSERVATIVE_8BIT_S1    (0x100 - 4)
 142 #define CONSERVATIVE_14BIT_S1   (0x4000 - 4)
 143 #define CONSERVATIVE_16BIT_S1   (0x10000 - 4)
 144 #define CONSERVATIVE_24BIT_S1   (0x1000000 - 4)
 145 /* These must be more conservative because the address may be in
 146    different segment.  */
 147 #define CONSERVATIVE_15BIT      (0x4000 - 0x1000)
 148 #define CONSERVATIVE_15BIT_S1   (0x8000 - 0x1000)
 149 #define CONSERVATIVE_15BIT_S2   (0x10000 - 0x1000)
 150 #define CONSERVATIVE_19BIT      (0x40000 - 0x1000)
 151 #define CONSERVATIVE_20BIT      (0x80000 - 0x1000)
 152
 153 /* Size of small data/bss sections, used to calculate SDA_BASE.  */
 154 static long got_size = 0;
 155 static int is_SDA_BASE_set = 0;
 156
 157 /* Convert ELF-VER in eflags to string for debugging purpose.  */
 158 static const char *const nds32_elfver_strtab[] =
 159 {
 160   "ELF-1.2",
 161   "ELF-1.3",
 162   "ELF-1.4",
 163 };
 164
 165 /* The nds32 linker needs to keep track of the number of relocs that it
 166    decides to copy in check_relocs for each symbol.  This is so that
 167    it can discard PC relative relocs if it doesn't need them when
 168    linking with -Bsymbolic.  We store the information in a field
 169    extending the regular ELF linker hash table.  */
 170
 171 /* This structure keeps track of the number of PC relative relocs we
 172    have copied for a given symbol.  */
 173
 174 struct elf_nds32_pcrel_relocs_copied
 175 {
 176   /* Next section.  */
 177   struct elf_nds32_pcrel_relocs_copied *next;
 178   /* A section in dynobj.  */
 179   asection *section;
 180   /* Number of relocs copied in this section.  */
 181   bfd_size_type count;
 182 };
 183
 184 enum elf_nds32_tls_type
 185 {
 186   GOT_UNKNOWN = (0),
 187   GOT_NORMAL = (1 << 0),
 188   GOT_TLS_LE = (1 << 1),
 189   GOT_TLS_IE = (1 << 2),
 190   GOT_TLS_IEGP = (1 << 3),
 191   GOT_TLS_LD = (1 << 4),
 192   GOT_TLS_GD = (1 << 5),
 193   GOT_TLS_DESC = (1 << 6),
 194 };
 195
 196 /* Nds32 ELF linker hash entry.  */
 197
 198 struct elf_nds32_link_hash_entry
 199 {
 200   struct elf_link_hash_entry root;
 201
 202   /* Track dynamic relocs copied for this symbol.  */
 203   struct elf_dyn_relocs *dyn_relocs;
 204
 205   /* For checking relocation type.  */
 206   enum elf_nds32_tls_type tls_type;
 207
 208   int offset_to_gp;
 209 };
 210
 211 /* Get the nds32 ELF linker hash table from a link_info structure.  */
 212
 213 #define FP_BASE_NAME "_FP_BASE_"
 214 static int check_start_export_sym = 0;
 215
 216 /* The offset for executable tls relaxation.  */
 217 #define TP_OFFSET 0x0
 218
 219 typedef struct
 220 {
 221   int min_id;
 222   int max_id;
 223   int count;
 224   int bias;
 225   int init;
 226 } elf32_nds32_relax_group_t;
 227
 228 struct elf_nds32_obj_tdata
 229 {
 230   struct elf_obj_tdata root;
 231
 232   /* tls_type for each local got entry.  */
 233   char *local_got_tls_type;
 234
 235   /* GOTPLT entries for TLS descriptors.  */
 236   bfd_vma *local_tlsdesc_gotent;
 237
 238   /* for R_NDS32_RELAX_GROUP handling.  */
 239   elf32_nds32_relax_group_t relax_group;
 240
 241   unsigned int hdr_size;
 242   int* offset_to_gp;
 243 };
 244
 245 #define elf_nds32_tdata(bfd) \
 246   ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
 247
 248 #define elf32_nds32_local_got_tls_type(bfd) \
 249   (elf_nds32_tdata (bfd)->local_got_tls_type)
 250
 251 #define elf32_nds32_local_gp_offset(bfd) \
 252   (elf_nds32_tdata (bfd)->offset_to_gp)
 253
 254 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
 255
 256 #define elf32_nds32_relax_group_ptr(bfd) \
 257   &(elf_nds32_tdata (bfd)->relax_group)
 258
 259 static bfd_boolean
 260 nds32_elf_mkobject (bfd *abfd)
 261 {
 262   return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
 263                                   NDS32_ELF_DATA);
 264 }
 265
 266 /* Relocations used for relocation.  */
 267 /* Define HOWTO2 (for relocation) and HOWTO3 (for relaxation) to
 268    initialize array nds32_elf_howto_table in any order. The benefit
 269    is that we can add any new relocations with any numbers and don't
 270    need to fill the gap by lots of EMPTY_HOWTO. */
 271 #define HOWTO2(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 272   [C] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
 273
 274 static reloc_howto_type nds32_elf_howto_table[] =
 275 {
 276   /* This reloc does nothing.  */
 277   HOWTO2 (R_NDS32_NONE,         /* type  */
 278          0,                     /* rightshift  */
 279          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 280          32,                    /* bitsize  */
 281          FALSE,                 /* pc_relative  */
 282          0,                     /* bitpos  */
 283          complain_overflow_bitfield,/* complain_on_overflow  */
 284          bfd_elf_generic_reloc, /* special_function  */
 285          "R_NDS32_NONE",        /* name  */
 286          FALSE,                 /* partial_inplace  */
 287          0,                     /* src_mask  */
 288          0,                     /* dst_mask  */
 289          FALSE),                /* pcrel_offset  */
 290
 291   /* A 16 bit absolute relocation.  */
 292   HOWTO2 (R_NDS32_16,           /* type  */
 293          0,                     /* rightshift  */
 294          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 295          16,                    /* bitsize  */
 296          FALSE,                 /* pc_relative  */
 297          0,                     /* bitpos  */
 298          complain_overflow_bitfield,/* complain_on_overflow  */
 299          nds32_elf_generic_reloc,/* special_function  */
 300          "R_NDS32_16",          /* name  */
 301          FALSE,                 /* partial_inplace  */
 302          0xffff,                /* src_mask  */
 303          0xffff,                /* dst_mask  */
 304          FALSE),                /* pcrel_offset  */
 305
 306   /* A 32 bit absolute relocation.  */
 307   HOWTO2 (R_NDS32_32,           /* type  */
 308          0,                     /* rightshift  */
 309          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 310          32,                    /* bitsize  */
 311          FALSE,                 /* pc_relative  */
 312          0,                     /* bitpos  */
 313          complain_overflow_bitfield,/* complain_on_overflow  */
 314          nds32_elf_generic_reloc,/* special_function  */
 315          "R_NDS32_32",          /* name  */
 316          FALSE,                 /* partial_inplace  */
 317          0xffffffff,            /* src_mask  */
 318          0xffffffff,            /* dst_mask  */
 319          FALSE),                /* pcrel_offset  */
 320
 321   /* A 20 bit address.  */
 322   HOWTO2 (R_NDS32_20,           /* type  */
 323          0,                     /* rightshift  */
 324          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 325          20,                    /* bitsize  */
 326          FALSE,                 /* pc_relative  */
 327          0,                     /* bitpos  */
 328          complain_overflow_unsigned,/* complain_on_overflow  */
 329          nds32_elf_generic_reloc,/* special_function  */
 330          "R_NDS32_20",          /* name  */
 331          FALSE,                 /* partial_inplace  */
 332          0xfffff,               /* src_mask  */
 333          0xfffff,               /* dst_mask  */
 334          FALSE),                /* pcrel_offset  */
 335
 336   /* An PC Relative 9-bit relocation, shifted by 2.
 337      This reloc is complicated because relocations are relative to pc & -4.
 338      i.e. branches in the right insn slot use the address of the left insn
 339      slot for pc.  */
 340   /* It's not clear whether this should have partial_inplace set or not.
 341      Branch relaxing in the assembler can store the addend in the insn,
 342      and if bfd_install_relocation gets called the addend may get added
 343      again.  */
 344   HOWTO2 (R_NDS32_9_PCREL,      /* type  */
 345          1,                     /* rightshift  */
 346          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 347          8,                     /* bitsize  */
 348          TRUE,                  /* pc_relative  */
 349          0,                     /* bitpos  */
 350          complain_overflow_signed,/* complain_on_overflow  */
 351          nds32_elf_9_pcrel_reloc,/* special_function  */
 352          "R_NDS32_9_PCREL",     /* name  */
 353          FALSE,                 /* partial_inplace  */
 354          0xff,                  /* src_mask  */
 355          0xff,                  /* dst_mask  */
 356          TRUE),                 /* pcrel_offset  */
 357
 358   /* A relative 15 bit relocation, right shifted by 1.  */
 359   HOWTO2 (R_NDS32_15_PCREL,     /* type  */
 360          1,                     /* rightshift  */
 361          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 362          14,                    /* bitsize  */
 363          TRUE,                  /* pc_relative  */
 364          0,                     /* bitpos  */
 365          complain_overflow_signed,/* complain_on_overflow  */
 366          bfd_elf_generic_reloc, /* special_function  */
 367          "R_NDS32_15_PCREL",    /* name  */
 368          FALSE,                 /* partial_inplace  */
 369          0x3fff,                /* src_mask  */
 370          0x3fff,                /* dst_mask  */
 371          TRUE),                 /* pcrel_offset  */
 372
 373   /* A relative 17 bit relocation, right shifted by 1.  */
 374   HOWTO2 (R_NDS32_17_PCREL,     /* type  */
 375          1,                     /* rightshift  */
 376          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 377          16,                    /* bitsize  */
 378          TRUE,                  /* pc_relative  */
 379          0,                     /* bitpos  */
 380          complain_overflow_signed,/* complain_on_overflow  */
 381          bfd_elf_generic_reloc, /* special_function  */
 382          "R_NDS32_17_PCREL",    /* name  */
 383          FALSE,                 /* partial_inplace  */
 384          0xffff,                /* src_mask  */
 385          0xffff,                /* dst_mask  */
 386          TRUE),                 /* pcrel_offset  */
 387
 388   /* A relative 25 bit relocation, right shifted by 1.  */
 389   /* It's not clear whether this should have partial_inplace set or not.
 390      Branch relaxing in the assembler can store the addend in the insn,
 391      and if bfd_install_relocation gets called the addend may get added
 392      again.  */
 393   HOWTO2 (R_NDS32_25_PCREL,     /* type  */
 394          1,                     /* rightshift  */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 396          24,                    /* bitsize  */
 397          TRUE,                  /* pc_relative  */
 398          0,                     /* bitpos  */
 399          complain_overflow_signed,/* complain_on_overflow  */
 400          bfd_elf_generic_reloc, /* special_function  */
 401          "R_NDS32_25_PCREL",    /* name  */
 402          FALSE,                 /* partial_inplace  */
 403          0xffffff,              /* src_mask  */
 404          0xffffff,              /* dst_mask  */
 405          TRUE),                 /* pcrel_offset  */
 406
 407   /* High 20 bits of address when lower 12 is or'd in.  */
 408   HOWTO2 (R_NDS32_HI20,         /* type  */
 409          12,                    /* rightshift  */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 411          20,                    /* bitsize  */
 412          FALSE,                 /* pc_relative  */
 413          0,                     /* bitpos  */
 414          complain_overflow_dont,/* complain_on_overflow  */
 415          nds32_elf_hi20_reloc,  /* special_function  */
 416          "R_NDS32_HI20",        /* name  */
 417          FALSE,                 /* partial_inplace  */
 418          0x000fffff,            /* src_mask  */
 419          0x000fffff,            /* dst_mask  */
 420          FALSE),                /* pcrel_offset  */
 421
 422   /* Lower 12 bits of address.  */
 423   HOWTO2 (R_NDS32_LO12S3,       /* type  */
 424          3,                     /* rightshift  */
 425          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 426          9,                     /* bitsize  */
 427          FALSE,                 /* pc_relative  */
 428          0,                     /* bitpos  */
 429          complain_overflow_dont,/* complain_on_overflow  */
 430          nds32_elf_lo12_reloc,  /* special_function  */
 431          "R_NDS32_LO12S3",      /* name  */
 432          FALSE,                 /* partial_inplace  */
 433          0x000001ff,            /* src_mask  */
 434          0x000001ff,            /* dst_mask  */
 435          FALSE),                /* pcrel_offset  */
 436
 437   /* Lower 12 bits of address.  */
 438   HOWTO2 (R_NDS32_LO12S2,       /* type  */
 439          2,                     /* rightshift  */
 440          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 441          10,                    /* bitsize  */
 442          FALSE,                 /* pc_relative  */
 443          0,                     /* bitpos  */
 444          complain_overflow_dont,/* complain_on_overflow  */
 445          nds32_elf_lo12_reloc,  /* special_function  */
 446          "R_NDS32_LO12S2",      /* name  */
 447          FALSE,                 /* partial_inplace  */
 448          0x000003ff,            /* src_mask  */
 449          0x000003ff,            /* dst_mask  */
 450          FALSE),                /* pcrel_offset  */
 451
 452   /* Lower 12 bits of address.  */
 453   HOWTO2 (R_NDS32_LO12S1,       /* type  */
 454          1,                     /* rightshift  */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 456          11,                    /* bitsize  */
 457          FALSE,                 /* pc_relative  */
 458          0,                     /* bitpos  */
 459          complain_overflow_dont,/* complain_on_overflow  */
 460          nds32_elf_lo12_reloc,  /* special_function  */
 461          "R_NDS32_LO12S1",      /* name  */
 462          FALSE,                 /* partial_inplace  */
 463          0x000007ff,            /* src_mask  */
 464          0x000007ff,            /* dst_mask  */
 465          FALSE),                /* pcrel_offset  */
 466
 467   /* Lower 12 bits of address.  */
 468   HOWTO2 (R_NDS32_LO12S0,       /* type  */
 469          0,                     /* rightshift  */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 471          12,                    /* bitsize  */
 472          FALSE,                 /* pc_relative  */
 473          0,                     /* bitpos  */
 474          complain_overflow_dont,/* complain_on_overflow  */
 475          nds32_elf_lo12_reloc,  /* special_function  */
 476          "R_NDS32_LO12S0",      /* name  */
 477          FALSE,                 /* partial_inplace  */
 478          0x00000fff,            /* src_mask  */
 479          0x00000fff,            /* dst_mask  */
 480          FALSE),                /* pcrel_offset  */
 481
 482   /* Small data area 15 bits offset.  */
 483   HOWTO2 (R_NDS32_SDA15S3,      /* type  */
 484          3,                     /* rightshift  */
 485          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 486          15,                    /* bitsize  */
 487          FALSE,                 /* pc_relative  */
 488          0,                     /* bitpos  */
 489          complain_overflow_signed,/* complain_on_overflow  */
 490          nds32_elf_sda15_reloc, /* special_function  */
 491          "R_NDS32_SDA15S3",     /* name  */
 492          FALSE,                 /* partial_inplace  */
 493          0x00007fff,            /* src_mask  */
 494          0x00007fff,            /* dst_mask  */
 495          FALSE),                /* pcrel_offset  */
 496
 497   /* Small data area 15 bits offset.  */
 498   HOWTO2 (R_NDS32_SDA15S2,      /* type  */
 499          2,                     /* rightshift  */
 500          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 501          15,                    /* bitsize  */
 502          FALSE,                 /* pc_relative  */
 503          0,                     /* bitpos  */
 504          complain_overflow_signed,/* complain_on_overflow  */
 505          nds32_elf_sda15_reloc, /* special_function  */
 506          "R_NDS32_SDA15S2",     /* name  */
 507          FALSE,                 /* partial_inplace  */
 508          0x00007fff,            /* src_mask  */
 509          0x00007fff,            /* dst_mask  */
 510          FALSE),                /* pcrel_offset  */
 511
 512   /* Small data area 15 bits offset.  */
 513   HOWTO2 (R_NDS32_SDA15S1,      /* type  */
 514          1,                     /* rightshift  */
 515          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 516          15,                    /* bitsize  */
 517          FALSE,                 /* pc_relative  */
 518          0,                     /* bitpos  */
 519          complain_overflow_signed,/* complain_on_overflow  */
 520          nds32_elf_sda15_reloc, /* special_function  */
 521          "R_NDS32_SDA15S1",     /* name  */
 522          FALSE,                 /* partial_inplace  */
 523          0x00007fff,            /* src_mask  */
 524          0x00007fff,            /* dst_mask  */
 525          FALSE),                /* pcrel_offset  */
 526
 527   /* Small data area 15 bits offset.  */
 528   HOWTO2 (R_NDS32_SDA15S0,      /* type  */
 529          0,                     /* rightshift  */
 530          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 531          15,                    /* bitsize  */
 532          FALSE,                 /* pc_relative  */
 533          0,                     /* bitpos  */
 534          complain_overflow_signed,/* complain_on_overflow  */
 535          nds32_elf_sda15_reloc, /* special_function  */
 536          "R_NDS32_SDA15S0",     /* name  */
 537          FALSE,                 /* partial_inplace  */
 538          0x00007fff,            /* src_mask  */
 539          0x00007fff,            /* dst_mask  */
 540          FALSE),                /* pcrel_offset  */
 541
 542   /* GNU extension to record C++ vtable hierarchy  */
 543   HOWTO2 (R_NDS32_GNU_VTINHERIT,/* type  */
 544          0,                     /* rightshift  */
 545          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 546          0,                     /* bitsize  */
 547          FALSE,                 /* pc_relative  */
 548          0,                     /* bitpos  */
 549          complain_overflow_dont,/* complain_on_overflow  */
 550          NULL,                  /* special_function  */
 551          "R_NDS32_GNU_VTINHERIT",/* name  */
 552          FALSE,                 /* partial_inplace  */
 553          0,                     /* src_mask  */
 554          0,                     /* dst_mask  */
 555          FALSE),                /* pcrel_offset  */
 556
 557   /* GNU extension to record C++ vtable member usage  */
 558   HOWTO2 (R_NDS32_GNU_VTENTRY,  /* type  */
 559          0,                     /* rightshift  */
 560          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 561          0,                     /* bitsize  */
 562          FALSE,                 /* pc_relative  */
 563          0,                     /* bitpos  */
 564          complain_overflow_dont,/* complain_on_overflow  */
 565          _bfd_elf_rel_vtable_reloc_fn,/* special_function  */
 566          "R_NDS32_GNU_VTENTRY", /* name  */
 567          FALSE,                 /* partial_inplace  */
 568          0,                     /* src_mask  */
 569          0,                     /* dst_mask  */
 570          FALSE),                /* pcrel_offset  */
 571
 572   /* A 16 bit absolute relocation.  */
 573   HOWTO2 (R_NDS32_16_RELA,      /* type  */
 574          0,                     /* rightshift  */
 575          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 576          16,                    /* bitsize  */
 577          FALSE,                 /* pc_relative  */
 578          0,                     /* bitpos  */
 579          complain_overflow_bitfield,/* complain_on_overflow  */
 580          bfd_elf_generic_reloc, /* special_function  */
 581          "R_NDS32_16_RELA",     /* name  */
 582          FALSE,                 /* partial_inplace  */
 583          0xffff,                /* src_mask  */
 584          0xffff,                /* dst_mask  */
 585          FALSE),                /* pcrel_offset  */
 586
 587   /* A 32 bit absolute relocation.  */
 588   HOWTO2 (R_NDS32_32_RELA,      /* type  */
 589          0,                     /* rightshift  */
 590          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 591          32,                    /* bitsize  */
 592          FALSE,                 /* pc_relative  */
 593          0,                     /* bitpos  */
 594          complain_overflow_bitfield,/* complain_on_overflow  */
 595          bfd_elf_generic_reloc, /* special_function  */
 596          "R_NDS32_32_RELA",     /* name  */
 597          FALSE,                 /* partial_inplace  */
 598          0xffffffff,            /* src_mask  */
 599          0xffffffff,            /* dst_mask  */
 600          FALSE),                /* pcrel_offset  */
 601
 602   /* A 20 bit address.  */
 603   HOWTO2 (R_NDS32_20_RELA,      /* type  */
 604          0,                     /* rightshift  */
 605          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 606          20,                    /* bitsize  */
 607          FALSE,                 /* pc_relative  */
 608          0,                     /* bitpos  */
 609          complain_overflow_signed,/* complain_on_overflow  */
 610          bfd_elf_generic_reloc, /* special_function  */
 611          "R_NDS32_20_RELA",     /* name  */
 612          FALSE,                 /* partial_inplace  */
 613          0xfffff,               /* src_mask  */
 614          0xfffff,               /* dst_mask  */
 615          FALSE),                /* pcrel_offset  */
 616
 617   HOWTO2 (R_NDS32_9_PCREL_RELA, /* type  */
 618          1,                     /* rightshift  */
 619          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 620          8,                     /* bitsize  */
 621          TRUE,                  /* pc_relative  */
 622          0,                     /* bitpos  */
 623          complain_overflow_signed,/* complain_on_overflow  */
 624          bfd_elf_generic_reloc, /* special_function  */
 625          "R_NDS32_9_PCREL_RELA",/* name  */
 626          FALSE,                 /* partial_inplace  */
 627          0xff,                  /* src_mask  */
 628          0xff,                  /* dst_mask  */
 629          TRUE),                 /* pcrel_offset  */
 630
 631   /* A relative 15 bit relocation, right shifted by 1.  */
 632   HOWTO2 (R_NDS32_15_PCREL_RELA,/* type  */
 633          1,                     /* rightshift  */
 634          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 635          14,                    /* bitsize  */
 636          TRUE,                  /* pc_relative  */
 637          0,                     /* bitpos  */
 638          complain_overflow_signed,/* complain_on_overflow  */
 639          bfd_elf_generic_reloc, /* special_function  */
 640          "R_NDS32_15_PCREL_RELA",/* name  */
 641          FALSE,                 /* partial_inplace  */
 642          0x3fff,                /* src_mask  */
 643          0x3fff,                /* dst_mask  */
 644          TRUE),                 /* pcrel_offset  */
 645
 646   /* A relative 17 bit relocation, right shifted by 1.  */
 647   HOWTO2 (R_NDS32_17_PCREL_RELA,/* type  */
 648          1,                     /* rightshift  */
 649          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 650          16,                    /* bitsize  */
 651          TRUE,                  /* pc_relative  */
 652          0,                     /* bitpos  */
 653          complain_overflow_signed,/* complain_on_overflow  */
 654          bfd_elf_generic_reloc, /* special_function  */
 655          "R_NDS32_17_PCREL_RELA",/* name  */
 656          FALSE,                 /* partial_inplace  */
 657          0xffff,                /* src_mask  */
 658          0xffff,                /* dst_mask  */
 659          TRUE),                 /* pcrel_offset  */
 660
 661   /* A relative 25 bit relocation, right shifted by 2.  */
 662   HOWTO2 (R_NDS32_25_PCREL_RELA,/* type  */
 663          1,                     /* rightshift  */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 665          24,                    /* bitsize  */
 666          TRUE,                  /* pc_relative  */
 667          0,                     /* bitpos  */
 668          complain_overflow_signed,/* complain_on_overflow  */
 669          bfd_elf_generic_reloc, /* special_function  */
 670          "R_NDS32_25_PCREL_RELA",/* name  */
 671          FALSE,                 /* partial_inplace  */
 672          0xffffff,              /* src_mask  */
 673          0xffffff,              /* dst_mask  */
 674          TRUE),                 /* pcrel_offset  */
 675
 676   /* High 20 bits of address when lower 16 is or'd in.  */
 677   HOWTO2 (R_NDS32_HI20_RELA,    /* type  */
 678          12,                    /* rightshift  */
 679          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 680          20,                    /* bitsize  */
 681          FALSE,                 /* pc_relative  */
 682          0,                     /* bitpos  */
 683          complain_overflow_dont,/* complain_on_overflow  */
 684          bfd_elf_generic_reloc, /* special_function  */
 685          "R_NDS32_HI20_RELA",   /* name  */
 686          FALSE,                 /* partial_inplace  */
 687          0x000fffff,            /* src_mask  */
 688          0x000fffff,            /* dst_mask  */
 689          FALSE),                /* pcrel_offset  */
 690
 691   /* Lower 12 bits of address.  */
 692   HOWTO2 (R_NDS32_LO12S3_RELA,  /* type  */
 693          3,                     /* rightshift  */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 695          9,                     /* bitsize  */
 696          FALSE,                 /* pc_relative  */
 697          0,                     /* bitpos  */
 698          complain_overflow_dont,/* complain_on_overflow  */
 699          bfd_elf_generic_reloc, /* special_function  */
 700          "R_NDS32_LO12S3_RELA", /* name  */
 701          FALSE,                 /* partial_inplace  */
 702          0x000001ff,            /* src_mask  */
 703          0x000001ff,            /* dst_mask  */
 704          FALSE),                /* pcrel_offset  */
 705
 706   /* Lower 12 bits of address.  */
 707   HOWTO2 (R_NDS32_LO12S2_RELA,  /* type  */
 708          2,                     /* rightshift  */
 709          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 710          10,                    /* bitsize  */
 711          FALSE,                 /* pc_relative  */
 712          0,                     /* bitpos  */
 713          complain_overflow_dont,/* complain_on_overflow  */
 714          bfd_elf_generic_reloc, /* special_function  */
 715          "R_NDS32_LO12S2_RELA", /* name  */
 716          FALSE,                 /* partial_inplace  */
 717          0x000003ff,            /* src_mask  */
 718          0x000003ff,            /* dst_mask  */
 719          FALSE),                /* pcrel_offset  */
 720
 721   /* Lower 12 bits of address.  */
 722   HOWTO2 (R_NDS32_LO12S1_RELA,  /* type  */
 723          1,                     /* rightshift  */
 724          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 725          11,                    /* bitsize  */
 726          FALSE,                 /* pc_relative  */
 727          0,                     /* bitpos  */
 728          complain_overflow_dont,/* complain_on_overflow  */
 729          bfd_elf_generic_reloc, /* special_function  */
 730          "R_NDS32_LO12S1_RELA", /* name  */
 731          FALSE,                 /* partial_inplace  */
 732          0x000007ff,            /* src_mask  */
 733          0x000007ff,            /* dst_mask  */
 734          FALSE),                /* pcrel_offset  */
 735
 736   /* Lower 12 bits of address.  */
 737   HOWTO2 (R_NDS32_LO12S0_RELA,  /* type  */
 738          0,                     /* rightshift  */
 739          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 740          12,                    /* bitsize  */
 741          FALSE,                 /* pc_relative  */
 742          0,                     /* bitpos  */
 743          complain_overflow_dont,/* complain_on_overflow  */
 744          bfd_elf_generic_reloc, /* special_function  */
 745          "R_NDS32_LO12S0_RELA", /* name  */
 746          FALSE,                 /* partial_inplace  */
 747          0x00000fff,            /* src_mask  */
 748          0x00000fff,            /* dst_mask  */
 749          FALSE),                /* pcrel_offset  */
 750
 751   /* Small data area 15 bits offset.  */
 752   HOWTO2 (R_NDS32_SDA15S3_RELA, /* type  */
 753          3,                     /* rightshift  */
 754          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 755          15,                    /* bitsize  */
 756          FALSE,                 /* pc_relative  */
 757          0,                     /* bitpos  */
 758          complain_overflow_signed,/* complain_on_overflow  */
 759          bfd_elf_generic_reloc, /* special_function  */
 760          "R_NDS32_SDA15S3_RELA",/* name  */
 761          FALSE,                 /* partial_inplace  */
 762          0x00007fff,            /* src_mask  */
 763          0x00007fff,            /* dst_mask  */
 764          FALSE),                /* pcrel_offset  */
 765
 766   /* Small data area 15 bits offset.  */
 767   HOWTO2 (R_NDS32_SDA15S2_RELA, /* type  */
 768          2,                     /* rightshift  */
 769          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 770          15,                    /* bitsize  */
 771          FALSE,                 /* pc_relative  */
 772          0,                     /* bitpos  */
 773          complain_overflow_signed,/* complain_on_overflow  */
 774          bfd_elf_generic_reloc, /* special_function  */
 775          "R_NDS32_SDA15S2_RELA",/* name  */
 776          FALSE,                 /* partial_inplace  */
 777          0x00007fff,            /* src_mask  */
 778          0x00007fff,            /* dst_mask  */
 779          FALSE),                /* pcrel_offset  */
 780
 781   HOWTO2 (R_NDS32_SDA15S1_RELA, /* type  */
 782          1,                     /* rightshift  */
 783          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 784          15,                    /* bitsize  */
 785          FALSE,                 /* pc_relative  */
 786          0,                     /* bitpos  */
 787          complain_overflow_signed,/* complain_on_overflow  */
 788          bfd_elf_generic_reloc, /* special_function  */
 789          "R_NDS32_SDA15S1_RELA",/* name  */
 790          FALSE,                 /* partial_inplace  */
 791          0x00007fff,            /* src_mask  */
 792          0x00007fff,            /* dst_mask  */
 793          FALSE),                /* pcrel_offset  */
 794
 795   HOWTO2 (R_NDS32_SDA15S0_RELA, /* type  */
 796          0,                     /* rightshift  */
 797          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 798          15,                    /* bitsize  */
 799          FALSE,                 /* pc_relative  */
 800          0,                     /* bitpos  */
 801          complain_overflow_signed,/* complain_on_overflow  */
 802          bfd_elf_generic_reloc, /* special_function  */
 803          "R_NDS32_SDA15S0_RELA",/* name  */
 804          FALSE,                 /* partial_inplace  */
 805          0x00007fff,            /* src_mask  */
 806          0x00007fff,            /* dst_mask  */
 807          FALSE),                /* pcrel_offset  */
 808
 809   /* GNU extension to record C++ vtable hierarchy  */
 810   HOWTO2 (R_NDS32_RELA_GNU_VTINHERIT,/* type  */
 811          0,                     /* rightshift  */
 812          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 813          0,                     /* bitsize  */
 814          FALSE,                 /* pc_relative  */
 815          0,                     /* bitpos  */
 816          complain_overflow_dont,/* complain_on_overflow  */
 817          NULL,                  /* special_function  */
 818          "R_NDS32_RELA_GNU_VTINHERIT",/* name  */
 819          FALSE,                 /* partial_inplace  */
 820          0,                     /* src_mask  */
 821          0,                     /* dst_mask  */
 822          FALSE),                /* pcrel_offset  */
 823
 824   /* GNU extension to record C++ vtable member usage  */
 825   HOWTO2 (R_NDS32_RELA_GNU_VTENTRY,/* type  */
 826          0,                     /* rightshift  */
 827          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 828          0,                     /* bitsize  */
 829          FALSE,                 /* pc_relative  */
 830          0,                     /* bitpos  */
 831          complain_overflow_dont,/* complain_on_overflow  */
 832          _bfd_elf_rel_vtable_reloc_fn,/* special_function  */
 833          "R_NDS32_RELA_GNU_VTENTRY",/* name  */
 834          FALSE,                 /* partial_inplace  */
 835          0,                     /* src_mask  */
 836          0,                     /* dst_mask  */
 837          FALSE),                /* pcrel_offset  */
 838
 839   /* Like R_NDS32_20, but referring to the GOT table entry for
 840      the symbol.  */
 841   HOWTO2 (R_NDS32_GOT20,        /* type  */
 842          0,                     /* rightshift  */
 843          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 844          20,                    /* bitsize  */
 845          FALSE,                 /* pc_relative  */
 846          0,                     /* bitpos  */
 847          complain_overflow_signed,/* complain_on_overflow  */
 848          bfd_elf_generic_reloc, /* special_function  */
 849          "R_NDS32_GOT20",       /* name  */
 850          FALSE,                 /* partial_inplace  */
 851          0xfffff,               /* src_mask  */
 852          0xfffff,               /* dst_mask  */
 853          FALSE),                /* pcrel_offset  */
 854
 855   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
 856      entry for the symbol.  */
 857   HOWTO2 (R_NDS32_25_PLTREL,    /* type  */
 858          1,                     /* rightshift  */
 859          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 860          24,                    /* bitsize  */
 861          TRUE,                  /* pc_relative  */
 862          0,                     /* bitpos  */
 863          complain_overflow_signed,/* complain_on_overflow  */
 864          bfd_elf_generic_reloc, /* special_function  */
 865          "R_NDS32_25_PLTREL",   /* name  */
 866          FALSE,                 /* partial_inplace  */
 867          0xffffff,              /* src_mask  */
 868          0xffffff,              /* dst_mask  */
 869          TRUE),                 /* pcrel_offset  */
 870
 871   /* This is used only by the dynamic linker.  The symbol should exist
 872      both in the object being run and in some shared library.  The
 873      dynamic linker copies the data addressed by the symbol from the
 874      shared library into the object, because the object being
 875      run has to have the data at some particular address.  */
 876   HOWTO2 (R_NDS32_COPY,         /* type  */
 877          0,                     /* rightshift  */
 878          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 879          32,                    /* bitsize  */
 880          FALSE,                 /* pc_relative  */
 881          0,                     /* bitpos  */
 882          complain_overflow_bitfield,/* complain_on_overflow  */
 883          bfd_elf_generic_reloc, /* special_function  */
 884          "R_NDS32_COPY",        /* name  */
 885          FALSE,                 /* partial_inplace  */
 886          0xffffffff,            /* src_mask  */
 887          0xffffffff,            /* dst_mask  */
 888          FALSE),                /* pcrel_offset  */
 889
 890   /* Like R_NDS32_20, but used when setting global offset table
 891      entries.  */
 892   HOWTO2 (R_NDS32_GLOB_DAT,     /* type  */
 893          0,                     /* rightshift  */
 894          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 895          32,                    /* bitsize  */
 896          FALSE,                 /* pc_relative  */
 897          0,                     /* bitpos  */
 898          complain_overflow_bitfield,/* complain_on_overflow  */
 899          bfd_elf_generic_reloc, /* special_function  */
 900          "R_NDS32_GLOB_DAT",    /* name  */
 901          FALSE,                 /* partial_inplace  */
 902          0xffffffff,            /* src_mask  */
 903          0xffffffff,            /* dst_mask  */
 904          FALSE),                /* pcrel_offset  */
 905
 906   /* Marks a procedure linkage table entry for a symbol.  */
 907   HOWTO2 (R_NDS32_JMP_SLOT,     /* type  */
 908          0,                     /* rightshift  */
 909          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 910          32,                    /* bitsize  */
 911          FALSE,                 /* pc_relative  */
 912          0,                     /* bitpos  */
 913          complain_overflow_bitfield,/* complain_on_overflow  */
 914          bfd_elf_generic_reloc, /* special_function  */
 915          "R_NDS32_JMP_SLOT",    /* name  */
 916          FALSE,                 /* partial_inplace  */
 917          0xffffffff,            /* src_mask  */
 918          0xffffffff,            /* dst_mask  */
 919          FALSE),                /* pcrel_offset  */
 920
 921   /* Used only by the dynamic linker.  When the object is run, this
 922      longword is set to the load address of the object, plus the
 923      addend.  */
 924   HOWTO2 (R_NDS32_RELATIVE,     /* type  */
 925          0,                     /* rightshift  */
 926          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 927          32,                    /* bitsize  */
 928          FALSE,                 /* pc_relative  */
 929          0,                     /* bitpos  */
 930          complain_overflow_bitfield,/* complain_on_overflow  */
 931          bfd_elf_generic_reloc, /* special_function  */
 932          "R_NDS32_RELATIVE",    /* name  */
 933          FALSE,                 /* partial_inplace  */
 934          0xffffffff,            /* src_mask  */
 935          0xffffffff,            /* dst_mask  */
 936          FALSE),                /* pcrel_offset  */
 937
 938   HOWTO2 (R_NDS32_GOTOFF,       /* type  */
 939          0,                     /* rightshift  */
 940          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 941          20,                    /* bitsize  */
 942          FALSE,                 /* pc_relative  */
 943          0,                     /* bitpos  */
 944          complain_overflow_signed,/* complain_on_overflow  */
 945          bfd_elf_generic_reloc, /* special_function  */
 946          "R_NDS32_GOTOFF",      /* name  */
 947          FALSE,                 /* partial_inplace  */
 948          0xfffff,               /* src_mask  */
 949          0xfffff,               /* dst_mask  */
 950          FALSE),                /* pcrel_offset  */
 951
 952   /* An PC Relative 20-bit relocation used when setting PIC offset
 953      table register.  */
 954   HOWTO2 (R_NDS32_GOTPC20,      /* type  */
 955          0,                     /* rightshift  */
 956          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 957          20,                    /* bitsize  */
 958          TRUE,                  /* pc_relative  */
 959          0,                     /* bitpos  */
 960          complain_overflow_signed,/* complain_on_overflow  */
 961          bfd_elf_generic_reloc, /* special_function  */
 962          "R_NDS32_GOTPC20",     /* name  */
 963          FALSE,                 /* partial_inplace  */
 964          0xfffff,               /* src_mask  */
 965          0xfffff,               /* dst_mask  */
 966          TRUE),                 /* pcrel_offset  */
 967
 968   /* Like R_NDS32_HI20, but referring to the GOT table entry for
 969      the symbol.  */
 970   HOWTO2 (R_NDS32_GOT_HI20,     /* type  */
 971          12,                    /* rightshift  */
 972          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 973          20,                    /* bitsize  */
 974          FALSE,                 /* pc_relative  */
 975          0,                     /* bitpos  */
 976          complain_overflow_dont,/* complain_on_overflow  */
 977          bfd_elf_generic_reloc, /* special_function  */
 978          "R_NDS32_GOT_HI20",    /* name  */
 979          FALSE,                 /* partial_inplace  */
 980          0x000fffff,            /* src_mask  */
 981          0x000fffff,            /* dst_mask  */
 982          FALSE),                /* pcrel_offset  */
 983   HOWTO2 (R_NDS32_GOT_LO12,     /* type  */
 984          0,                     /* rightshift  */
 985          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 986          12,                    /* bitsize  */
 987          FALSE,                 /* pc_relative  */
 988          0,                     /* bitpos  */
 989          complain_overflow_dont,/* complain_on_overflow  */
 990          bfd_elf_generic_reloc, /* special_function  */
 991          "R_NDS32_GOT_LO12",    /* name  */
 992          FALSE,                 /* partial_inplace  */
 993          0x00000fff,            /* src_mask  */
 994          0x00000fff,            /* dst_mask  */
 995          FALSE),                /* pcrel_offset  */
 996
 997   /* An PC Relative relocation used when setting PIC offset table register.
 998      Like R_NDS32_HI20, but referring to the GOT table entry for
 999      the symbol.  */
1000   HOWTO2 (R_NDS32_GOTPC_HI20,   /* type  */
1001          12,                    /* rightshift  */
1002          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1003          20,                    /* bitsize  */
1004          FALSE,                 /* pc_relative  */
1005          0,                     /* bitpos  */
1006          complain_overflow_dont,/* complain_on_overflow  */
1007          bfd_elf_generic_reloc, /* special_function  */
1008          "R_NDS32_GOTPC_HI20",  /* name  */
1009          FALSE,                 /* partial_inplace  */
1010          0x000fffff,            /* src_mask  */
1011          0x000fffff,            /* dst_mask  */
1012          TRUE),                 /* pcrel_offset  */
1013   HOWTO2 (R_NDS32_GOTPC_LO12,   /* type  */
1014          0,                     /* rightshift  */
1015          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1016          12,                    /* bitsize  */
1017          FALSE,                 /* pc_relative  */
1018          0,                     /* bitpos  */
1019          complain_overflow_dont,/* complain_on_overflow  */
1020          bfd_elf_generic_reloc, /* special_function  */
1021          "R_NDS32_GOTPC_LO12",  /* name  */
1022          FALSE,                 /* partial_inplace  */
1023          0x00000fff,            /* src_mask  */
1024          0x00000fff,            /* dst_mask  */
1025          TRUE),                 /* pcrel_offset  */
1026
1027   HOWTO2 (R_NDS32_GOTOFF_HI20,  /* type  */
1028          12,                    /* rightshift  */
1029          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1030          20,                    /* bitsize  */
1031          FALSE,                 /* pc_relative  */
1032          0,                     /* bitpos  */
1033          complain_overflow_dont,/* complain_on_overflow  */
1034          bfd_elf_generic_reloc, /* special_function  */
1035          "R_NDS32_GOTOFF_HI20", /* name  */
1036          FALSE,                 /* partial_inplace  */
1037          0x000fffff,            /* src_mask  */
1038          0x000fffff,            /* dst_mask  */
1039          FALSE),                /* pcrel_offset  */
1040   HOWTO2 (R_NDS32_GOTOFF_LO12,  /* type  */
1041          0,                     /* rightshift  */
1042          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1043          12,                    /* bitsize  */
1044          FALSE,                 /* pc_relative  */
1045          0,                     /* bitpos  */
1046          complain_overflow_dont,/* complain_on_overflow  */
1047          bfd_elf_generic_reloc, /* special_function  */
1048          "R_NDS32_GOTOFF_LO12", /* name  */
1049          FALSE,                 /* partial_inplace  */
1050          0x00000fff,            /* src_mask  */
1051          0x00000fff,            /* dst_mask  */
1052          FALSE),                /* pcrel_offset  */
1053
1054   /* Alignment hint for relaxable instruction.  This is used with
1055      R_NDS32_LABEL as a pair.  Relax this instruction from 4 bytes to 2
1056      in order to make next label aligned on word boundary.  */
1057   HOWTO2 (R_NDS32_INSN16,       /* type  */
1058          0,                     /* rightshift  */
1059          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1060          32,                    /* bitsize  */
1061          FALSE,                 /* pc_relative  */
1062          0,                     /* bitpos  */
1063          complain_overflow_dont,/* complain_on_overflow  */
1064          nds32_elf_ignore_reloc,/* special_function  */
1065          "R_NDS32_INSN16",      /* name  */
1066          FALSE,                 /* partial_inplace  */
1067          0x00000fff,            /* src_mask  */
1068          0x00000fff,            /* dst_mask  */
1069          FALSE),                /* pcrel_offset  */
1070
1071   /* Alignment hint for label.  */
1072   HOWTO2 (R_NDS32_LABEL,        /* type  */
1073          0,                     /* rightshift  */
1074          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1075          32,                    /* bitsize  */
1076          FALSE,                 /* pc_relative  */
1077          0,                     /* bitpos  */
1078          complain_overflow_dont,/* complain_on_overflow  */
1079          nds32_elf_ignore_reloc,/* special_function  */
1080          "R_NDS32_LABEL",       /* name  */
1081          FALSE,                 /* partial_inplace  */
1082          0xffffffff,            /* src_mask  */
1083          0xffffffff,            /* dst_mask  */
1084          FALSE),                /* pcrel_offset  */
1085
1086   /* Relax hint for unconditional call sequence  */
1087   HOWTO2 (R_NDS32_LONGCALL1,    /* type  */
1088          0,                     /* rightshift  */
1089          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1090          32,                    /* bitsize  */
1091          FALSE,                 /* pc_relative  */
1092          0,                     /* bitpos  */
1093          complain_overflow_dont,/* complain_on_overflow  */
1094          nds32_elf_ignore_reloc,/* special_function  */
1095          "R_NDS32_LONGCALL1",   /* name  */
1096          FALSE,                 /* partial_inplace  */
1097          0xffffffff,            /* src_mask  */
1098          0xffffffff,            /* dst_mask  */
1099          FALSE),                /* pcrel_offset  */
1100
1101   /* Relax hint for conditional call sequence.  */
1102   HOWTO2 (R_NDS32_LONGCALL2,    /* type  */
1103          0,                     /* rightshift  */
1104          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1105          32,                    /* bitsize  */
1106          FALSE,                 /* pc_relative  */
1107          0,                     /* bitpos  */
1108          complain_overflow_dont,/* complain_on_overflow  */
1109          nds32_elf_ignore_reloc,/* special_function  */
1110          "R_NDS32_LONGCALL2",   /* name  */
1111          FALSE,                 /* partial_inplace  */
1112          0xffffffff,            /* src_mask  */
1113          0xffffffff,            /* dst_mask  */
1114          FALSE),                /* pcrel_offset  */
1115
1116   /* Relax hint for conditional call sequence.  */
1117   HOWTO2 (R_NDS32_LONGCALL3,    /* type  */
1118          0,                     /* rightshift  */
1119          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1120          32,                    /* bitsize  */
1121          FALSE,                 /* pc_relative  */
1122          0,                     /* bitpos  */
1123          complain_overflow_dont,/* complain_on_overflow  */
1124          nds32_elf_ignore_reloc,/* special_function  */
1125          "R_NDS32_LONGCALL3",   /* name  */
1126          FALSE,                 /* partial_inplace  */
1127          0xffffffff,            /* src_mask  */
1128          0xffffffff,            /* dst_mask  */
1129          FALSE),                /* pcrel_offset  */
1130
1131   /* Relax hint for unconditional branch sequence.  */
1132   HOWTO2 (R_NDS32_LONGJUMP1,    /* type  */
1133          0,                     /* rightshift  */
1134          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1135          32,                    /* bitsize  */
1136          FALSE,                 /* pc_relative  */
1137          0,                     /* bitpos  */
1138          complain_overflow_dont,/* complain_on_overflow  */
1139          nds32_elf_ignore_reloc,/* special_function  */
1140          "R_NDS32_LONGJUMP1",   /* name  */
1141          FALSE,                 /* partial_inplace  */
1142          0xffffffff,            /* src_mask  */
1143          0xffffffff,            /* dst_mask  */
1144          FALSE),                /* pcrel_offset  */
1145
1146   /* Relax hint for conditional branch sequence.  */
1147   HOWTO2 (R_NDS32_LONGJUMP2,    /* type  */
1148          0,                     /* rightshift  */
1149          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1150          32,                    /* bitsize  */
1151          FALSE,                 /* pc_relative  */
1152          0,                     /* bitpos  */
1153          complain_overflow_dont,/* complain_on_overflow  */
1154          nds32_elf_ignore_reloc,/* special_function  */
1155          "R_NDS32_LONGJUMP2",   /* name  */
1156          FALSE,                 /* partial_inplace  */
1157          0xffffffff,            /* src_mask  */
1158          0xffffffff,            /* dst_mask  */
1159          FALSE),                /* pcrel_offset  */
1160
1161   /* Relax hint for conditional branch sequence.  */
1162   HOWTO2 (R_NDS32_LONGJUMP3,    /* type  */
1163          0,                     /* rightshift  */
1164          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1165          32,                    /* bitsize  */
1166          FALSE,                 /* pc_relative  */
1167          0,                     /* bitpos  */
1168          complain_overflow_dont,/* complain_on_overflow  */
1169          nds32_elf_ignore_reloc,/* special_function  */
1170          "R_NDS32_LONGJUMP3",   /* name  */
1171          FALSE,                 /* partial_inplace  */
1172          0xffffffff,            /* src_mask  */
1173          0xffffffff,            /* dst_mask  */
1174          FALSE),                /* pcrel_offset  */
1175
1176   /* Relax hint for load/store sequence.   */
1177   HOWTO2 (R_NDS32_LOADSTORE,    /* type  */
1178          0,                     /* rightshift  */
1179          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1180          32,                    /* bitsize  */
1181          FALSE,                 /* pc_relative  */
1182          0,                     /* bitpos  */
1183          complain_overflow_dont,/* complain_on_overflow  */
1184          nds32_elf_ignore_reloc,/* special_function  */
1185          "R_NDS32_LOADSTORE",   /* name  */
1186          FALSE,                 /* partial_inplace  */
1187          0xffffffff,            /* src_mask  */
1188          0xffffffff,            /* dst_mask  */
1189          FALSE),                /* pcrel_offset  */
1190
1191   /* Relax hint for load/store sequence.  */
1192   HOWTO2 (R_NDS32_9_FIXED_RELA, /* type  */
1193          0,                     /* rightshift  */
1194          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1195          16,                    /* bitsize  */
1196          FALSE,                 /* pc_relative  */
1197          0,                     /* bitpos  */
1198          complain_overflow_dont,/* complain_on_overflow  */
1199          nds32_elf_ignore_reloc,/* special_function  */
1200          "R_NDS32_9_FIXED_RELA",/* name  */
1201          FALSE,                 /* partial_inplace  */
1202          0x000000ff,            /* src_mask  */
1203          0x000000ff,            /* dst_mask  */
1204          FALSE),                /* pcrel_offset  */
1205
1206   /* Relax hint for load/store sequence.  */
1207   HOWTO2 (R_NDS32_15_FIXED_RELA,/* type  */
1208          0,                     /* rightshift  */
1209          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1210          32,                    /* bitsize  */
1211          FALSE,                 /* pc_relative  */
1212          0,                     /* bitpos  */
1213          complain_overflow_dont,/* complain_on_overflow  */
1214          nds32_elf_ignore_reloc,/* special_function  */
1215          "R_NDS32_15_FIXED_RELA",/* name  */
1216          FALSE,                 /* partial_inplace  */
1217          0x00003fff,            /* src_mask  */
1218          0x00003fff,            /* dst_mask  */
1219          FALSE),                /* pcrel_offset  */
1220
1221   /* Relax hint for load/store sequence.  */
1222   HOWTO2 (R_NDS32_17_FIXED_RELA,/* type  */
1223          0,                     /* rightshift  */
1224          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1225          32,                    /* bitsize  */
1226          FALSE,                 /* pc_relative  */
1227          0,                     /* bitpos  */
1228          complain_overflow_dont,/* complain_on_overflow  */
1229          nds32_elf_ignore_reloc,/* special_function  */
1230          "R_NDS32_17_FIXED_RELA",/* name  */
1231          FALSE,                 /* partial_inplace  */
1232          0x0000ffff,            /* src_mask  */
1233          0x0000ffff,            /* dst_mask  */
1234          FALSE),                /* pcrel_offset  */
1235
1236   /* Relax hint for load/store sequence.  */
1237   HOWTO2 (R_NDS32_25_FIXED_RELA,/* type  */
1238          0,                     /* rightshift  */
1239          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1240          32,                    /* bitsize  */
1241          FALSE,                 /* pc_relative  */
1242          0,                     /* bitpos  */
1243          complain_overflow_dont,/* complain_on_overflow  */
1244          nds32_elf_ignore_reloc,/* special_function  */
1245          "R_NDS32_25_FIXED_RELA",/* name  */
1246          FALSE,                 /* partial_inplace  */
1247          0x00ffffff,            /* src_mask  */
1248          0x00ffffff,            /* dst_mask  */
1249          FALSE),                /* pcrel_offset  */
1250
1251   /* High 20 bits of PLT symbol offset relative to PC.  */
1252   HOWTO2 (R_NDS32_PLTREL_HI20,  /* type  */
1253          12,                    /* rightshift  */
1254          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1255          20,                    /* bitsize  */
1256          FALSE,                 /* pc_relative  */
1257          0,                     /* bitpos  */
1258          complain_overflow_dont,/* complain_on_overflow  */
1259          bfd_elf_generic_reloc, /* special_function  */
1260          "R_NDS32_PLTREL_HI20", /* name  */
1261          FALSE,                 /* partial_inplace  */
1262          0x000fffff,            /* src_mask  */
1263          0x000fffff,            /* dst_mask  */
1264          FALSE),                /* pcrel_offset  */
1265
1266   /* Low 12 bits of PLT symbol offset relative to PC.  */
1267   HOWTO2 (R_NDS32_PLTREL_LO12,  /* type  */
1268          0,                     /* rightshift  */
1269          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1270          12,                    /* bitsize  */
1271          FALSE,                 /* pc_relative  */
1272          0,                     /* bitpos  */
1273          complain_overflow_dont,/* complain_on_overflow  */
1274          bfd_elf_generic_reloc, /* special_function  */
1275          "R_NDS32_PLTREL_LO12", /* name  */
1276          FALSE,                 /* partial_inplace  */
1277          0x00000fff,            /* src_mask  */
1278          0x00000fff,            /* dst_mask  */
1279          FALSE),                /* pcrel_offset  */
1280
1281   /* High 20 bits of PLT symbol offset relative to GOT (GP).  */
1282   HOWTO2 (R_NDS32_PLT_GOTREL_HI20,      /* type  */
1283          12,                    /* rightshift  */
1284          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1285          20,                    /* bitsize  */
1286          FALSE,                 /* pc_relative  */
1287          0,                     /* bitpos  */
1288          complain_overflow_dont,/* complain_on_overflow  */
1289          bfd_elf_generic_reloc, /* special_function  */
1290          "R_NDS32_PLT_GOTREL_HI20",/* name  */
1291          FALSE,                 /* partial_inplace  */
1292          0x000fffff,            /* src_mask  */
1293          0x000fffff,            /* dst_mask  */
1294          FALSE),                /* pcrel_offset  */
1295
1296   /* Low 12 bits of PLT symbol offset relative to GOT (GP).  */
1297   HOWTO2 (R_NDS32_PLT_GOTREL_LO12,/* type  */
1298          0,                     /* rightshift  */
1299          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1300          12,                    /* bitsize  */
1301          FALSE,                 /* pc_relative  */
1302          0,                     /* bitpos  */
1303          complain_overflow_dont,/* complain_on_overflow  */
1304          bfd_elf_generic_reloc, /* special_function  */
1305          "R_NDS32_PLT_GOTREL_LO12",/* name  */
1306          FALSE,                 /* partial_inplace  */
1307          0x00000fff,            /* src_mask  */
1308          0x00000fff,            /* dst_mask  */
1309          FALSE),                /* pcrel_offset  */
1310
1311   /* Small data area 12 bits offset.  */
1312   HOWTO2 (R_NDS32_SDA12S2_DP_RELA,/* type  */
1313          2,                     /* rightshift  */
1314          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1315          12,                    /* bitsize  */
1316          FALSE,                 /* pc_relative  */
1317          0,                     /* bitpos  */
1318          complain_overflow_signed,/* complain_on_overflow  */
1319          bfd_elf_generic_reloc, /* special_function  */
1320          "R_NDS32_SDA12S2_DP_RELA",/* name  */
1321          FALSE,                 /* partial_inplace  */
1322          0x00000fff,            /* src_mask  */
1323          0x00000fff,            /* dst_mask  */
1324          FALSE),                /* pcrel_offset  */
1325
1326   /* Small data area 12 bits offset.  */
1327   HOWTO2 (R_NDS32_SDA12S2_SP_RELA,/* type  */
1328          2,                     /* rightshift  */
1329          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1330          12,                    /* bitsize  */
1331          FALSE,                 /* pc_relative  */
1332          0,                     /* bitpos  */
1333          complain_overflow_signed,/* complain_on_overflow  */
1334          bfd_elf_generic_reloc, /* special_function  */
1335          "R_NDS32_SDA12S2_SP_RELA",/* name  */
1336          FALSE,                 /* partial_inplace  */
1337          0x00000fff,            /* src_mask  */
1338          0x00000fff,            /* dst_mask  */
1339          FALSE),                /* pcrel_offset  */
1340   /* Lower 12 bits of address.  */
1341
1342   HOWTO2 (R_NDS32_LO12S2_DP_RELA,       /* type  */
1343          2,                     /* rightshift  */
1344          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1345          10,                    /* bitsize  */
1346          FALSE,                 /* pc_relative  */
1347          0,                     /* bitpos  */
1348          complain_overflow_dont,/* complain_on_overflow  */
1349          bfd_elf_generic_reloc, /* special_function  */
1350          "R_NDS32_LO12S2_DP_RELA",/* name  */
1351          FALSE,                 /* partial_inplace  */
1352          0x000003ff,            /* src_mask  */
1353          0x000003ff,            /* dst_mask  */
1354          FALSE),                /* pcrel_offset  */
1355
1356   /* Lower 12 bits of address.  */
1357   HOWTO2 (R_NDS32_LO12S2_SP_RELA,/* type  */
1358          2,                     /* rightshift  */
1359          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1360          10,                    /* bitsize  */
1361          FALSE,                 /* pc_relative  */
1362          0,                     /* bitpos  */
1363          complain_overflow_dont,/* complain_on_overflow  */
1364          bfd_elf_generic_reloc, /* special_function  */
1365          "R_NDS32_LO12S2_SP_RELA",/* name  */
1366          FALSE,                 /* partial_inplace  */
1367          0x000003ff,            /* src_mask  */
1368          0x000003ff,            /* dst_mask  */
1369          FALSE),                /* pcrel_offset  */
1370   /* Lower 12 bits of address.  Special identity for or case.  */
1371   HOWTO2 (R_NDS32_LO12S0_ORI_RELA,/* type  */
1372          0,                     /* rightshift  */
1373          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1374          12,                    /* bitsize  */
1375          FALSE,                 /* pc_relative  */
1376          0,                     /* bitpos  */
1377          complain_overflow_dont,/* complain_on_overflow  */
1378          bfd_elf_generic_reloc, /* special_function  */
1379          "R_NDS32_LO12S0_ORI_RELA",/* name  */
1380          FALSE,                 /* partial_inplace  */
1381          0x00000fff,            /* src_mask  */
1382          0x00000fff,            /* dst_mask  */
1383          FALSE),                /* pcrel_offset  */
1384   /* Small data area 19 bits offset.  */
1385   HOWTO2 (R_NDS32_SDA16S3_RELA, /* type  */
1386          3,                     /* rightshift  */
1387          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1388          16,                    /* bitsize  */
1389          FALSE,                 /* pc_relative  */
1390          0,                     /* bitpos  */
1391          complain_overflow_signed,/* complain_on_overflow  */
1392          bfd_elf_generic_reloc, /* special_function  */
1393          "R_NDS32_SDA16S3_RELA",/* name  */
1394          FALSE,                 /* partial_inplace  */
1395          0x0000ffff,            /* src_mask  */
1396          0x0000ffff,            /* dst_mask  */
1397          FALSE),                /* pcrel_offset  */
1398
1399   /* Small data area 15 bits offset.  */
1400   HOWTO2 (R_NDS32_SDA17S2_RELA, /* type  */
1401          2,                     /* rightshift  */
1402          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1403          17,                    /* bitsize  */
1404          FALSE,                 /* pc_relative  */
1405          0,                     /* bitpos  */
1406          complain_overflow_signed,/* complain_on_overflow  */
1407          bfd_elf_generic_reloc, /* special_function  */
1408          "R_NDS32_SDA17S2_RELA",/* name  */
1409          FALSE,                 /* partial_inplace  */
1410          0x0001ffff,            /* src_mask  */
1411          0x0001ffff,            /* dst_mask  */
1412          FALSE),                /* pcrel_offset  */
1413
1414   HOWTO2 (R_NDS32_SDA18S1_RELA, /* type  */
1415          1,                     /* rightshift  */
1416          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1417          18,                    /* bitsize  */
1418          FALSE,                 /* pc_relative  */
1419          0,                     /* bitpos  */
1420          complain_overflow_signed,/* complain_on_overflow  */
1421          bfd_elf_generic_reloc, /* special_function  */
1422          "R_NDS32_SDA18S1_RELA",/* name  */
1423          FALSE,                 /* partial_inplace  */
1424          0x0003ffff,            /* src_mask  */
1425          0x0003ffff,            /* dst_mask  */
1426          FALSE),                /* pcrel_offset  */
1427
1428   HOWTO2 (R_NDS32_SDA19S0_RELA, /* type  */
1429          0,                     /* rightshift  */
1430          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1431          19,                    /* bitsize  */
1432          FALSE,                 /* pc_relative  */
1433          0,                     /* bitpos  */
1434          complain_overflow_signed,/* complain_on_overflow  */
1435          bfd_elf_generic_reloc, /* special_function  */
1436          "R_NDS32_SDA19S0_RELA",/* name  */
1437          FALSE,                 /* partial_inplace  */
1438          0x0007ffff,            /* src_mask  */
1439          0x0007ffff,            /* dst_mask  */
1440          FALSE),                /* pcrel_offset  */
1441   HOWTO2 (R_NDS32_DWARF2_OP1_RELA,/* type  */
1442          0,                     /* rightshift  */
1443          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
1444          8,                     /* bitsize  */
1445          FALSE,                 /* pc_relative  */
1446          0,                     /* bitpos  */
1447          complain_overflow_dont,/* complain_on_overflow  */
1448          nds32_elf_ignore_reloc,/* special_function  */
1449          "R_NDS32_DWARF2_OP1_RELA",/* name  */
1450          FALSE,                 /* partial_inplace  */
1451          0xff,                  /* src_mask  */
1452          0xff,                  /* dst_mask  */
1453          FALSE),                /* pcrel_offset  */
1454   HOWTO2 (R_NDS32_DWARF2_OP2_RELA,/* type  */
1455          0,                     /* rightshift  */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1457          16,                    /* bitsize  */
1458          FALSE,                 /* pc_relative  */
1459          0,                     /* bitpos  */
1460          complain_overflow_dont,/* complain_on_overflow  */
1461          nds32_elf_ignore_reloc,/* special_function  */
1462          "R_NDS32_DWARF2_OP2_RELA",/* name  */
1463          FALSE,                 /* partial_inplace  */
1464          0xffff,                /* src_mask  */
1465          0xffff,                /* dst_mask  */
1466          FALSE),                /* pcrel_offset  */
1467   HOWTO2 (R_NDS32_DWARF2_LEB_RELA,/* type  */
1468          0,                     /* rightshift  */
1469          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1470          32,                    /* bitsize  */
1471          FALSE,                 /* pc_relative  */
1472          0,                     /* bitpos  */
1473          complain_overflow_dont,/* complain_on_overflow  */
1474          nds32_elf_ignore_reloc,/* special_function  */
1475          "R_NDS32_DWARF2_LEB_RELA",/* name  */
1476          FALSE,                 /* partial_inplace  */
1477          0xffffffff,            /* src_mask  */
1478          0xffffffff,            /* dst_mask  */
1479          FALSE),                /* pcrel_offset  */
1480   HOWTO2 (R_NDS32_UPDATE_TA_RELA,/* type  */
1481          0,                     /* rightshift  */
1482          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1483          16,                    /* bitsize  */
1484          FALSE,                 /* pc_relative  */
1485          0,                     /* bitpos  */
1486          complain_overflow_dont,/* complain_on_overflow  */
1487          nds32_elf_ignore_reloc,/* special_function  */
1488          "R_NDS32_UPDATE_TA_RELA",/* name  */
1489          FALSE,                 /* partial_inplace  */
1490          0xffff,                /* src_mask  */
1491          0xffff,                /* dst_mask  */
1492          FALSE),                /* pcrel_offset  */
1493   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1494      entry for the symbol.  */
1495   HOWTO2 (R_NDS32_9_PLTREL,     /* type  */
1496          1,                     /* rightshift  */
1497          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1498          8,                     /* bitsize  */
1499          TRUE,                  /* pc_relative  */
1500          0,                     /* bitpos  */
1501          complain_overflow_signed,/* complain_on_overflow  */
1502          bfd_elf_generic_reloc, /* special_function  */
1503          "R_NDS32_9_PLTREL",    /* name  */
1504          FALSE,                 /* partial_inplace  */
1505          0xff,                  /* src_mask  */
1506          0xff,                  /* dst_mask  */
1507          TRUE),                 /* pcrel_offset  */
1508   /* Low 20 bits of PLT symbol offset relative to GOT (GP).  */
1509   HOWTO2 (R_NDS32_PLT_GOTREL_LO20,/* type  */
1510          0,                     /* rightshift  */
1511          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1512          20,                    /* bitsize  */
1513          FALSE,                 /* pc_relative  */
1514          0,                     /* bitpos  */
1515          complain_overflow_dont,/* complain_on_overflow  */
1516          bfd_elf_generic_reloc, /* special_function  */
1517          "R_NDS32_PLT_GOTREL_LO20",/* name  */
1518          FALSE,                 /* partial_inplace  */
1519          0x000fffff,            /* src_mask  */
1520          0x000fffff,            /* dst_mask  */
1521          FALSE),                /* pcrel_offset  */
1522   /* low 15 bits of PLT symbol offset relative to GOT (GP)  */
1523   HOWTO2 (R_NDS32_PLT_GOTREL_LO15,/* type  */
1524          0,                     /* rightshift  */
1525          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1526          15,                    /* bitsize  */
1527          FALSE,                 /* pc_relative  */
1528          0,                     /* bitpos  */
1529          complain_overflow_dont,/* complain_on_overflow  */
1530          bfd_elf_generic_reloc, /* special_function  */
1531          "R_NDS32_PLT_GOTREL_LO15",/* name  */
1532          FALSE,                 /* partial_inplace  */
1533          0x00007fff,            /* src_mask  */
1534          0x00007fff,            /* dst_mask  */
1535          FALSE),                /* pcrel_offset  */
1536   /* Low 19 bits of PLT symbol offset relative to GOT (GP).  */
1537   HOWTO2 (R_NDS32_PLT_GOTREL_LO19,/* type  */
1538          0,                     /* rightshift  */
1539          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1540          19,                    /* bitsize  */
1541          FALSE,                 /* pc_relative  */
1542          0,                     /* bitpos  */
1543          complain_overflow_dont,/* complain_on_overflow  */
1544          bfd_elf_generic_reloc, /* special_function  */
1545          "R_NDS32_PLT_GOTREL_LO19",/* name  */
1546          FALSE,                 /* partial_inplace  */
1547          0x0007ffff,            /* src_mask  */
1548          0x0007ffff,            /* dst_mask  */
1549          FALSE),                /* pcrel_offset  */
1550   HOWTO2 (R_NDS32_GOT_LO15,     /* type  */
1551          0,                     /* rightshift  */
1552          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1553          15,                    /* bitsize  */
1554          FALSE,                 /* pc_relative  */
1555          0,                     /* bitpos  */
1556          complain_overflow_dont,/* complain_on_overflow  */
1557          bfd_elf_generic_reloc, /* special_function  */
1558          "R_NDS32_GOT_LO15",    /* name  */
1559          FALSE,                 /* partial_inplace  */
1560          0x00007fff,            /* src_mask  */
1561          0x00007fff,            /* dst_mask  */
1562          FALSE),                /* pcrel_offset  */
1563   HOWTO2 (R_NDS32_GOT_LO19,     /* type  */
1564          0,                     /* rightshift  */
1565          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1566          19,                    /* bitsize  */
1567          FALSE,                 /* pc_relative  */
1568          0,                     /* bitpos  */
1569          complain_overflow_dont,/* complain_on_overflow  */
1570          bfd_elf_generic_reloc, /* special_function  */
1571          "R_NDS32_GOT_LO19",    /* name  */
1572          FALSE,                 /* partial_inplace  */
1573          0x0007ffff,            /* src_mask  */
1574          0x0007ffff,            /* dst_mask  */
1575          FALSE),                /* pcrel_offset  */
1576   HOWTO2 (R_NDS32_GOTOFF_LO15,  /* type  */
1577          0,                     /* rightshift  */
1578          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1579          15,                    /* bitsize  */
1580          FALSE,                 /* pc_relative  */
1581          0,                     /* bitpos  */
1582          complain_overflow_dont,/* complain_on_overflow  */
1583          bfd_elf_generic_reloc, /* special_function  */
1584          "R_NDS32_GOTOFF_LO15", /* name  */
1585          FALSE,                 /* partial_inplace  */
1586          0x00007fff,            /* src_mask  */
1587          0x00007fff,            /* dst_mask  */
1588          FALSE),                /* pcrel_offset  */
1589   HOWTO2 (R_NDS32_GOTOFF_LO19,  /* type  */
1590          0,                     /* rightshift  */
1591          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1592          19,                    /* bitsize  */
1593          FALSE,                 /* pc_relative  */
1594          0,                     /* bitpos  */
1595          complain_overflow_dont,/* complain_on_overflow  */
1596          bfd_elf_generic_reloc, /* special_function  */
1597          "R_NDS32_GOTOFF_LO19", /* name  */
1598          FALSE,                 /* partial_inplace  */
1599          0x0007ffff,            /* src_mask  */
1600          0x0007ffff,            /* dst_mask  */
1601          FALSE),                /* pcrel_offset  */
1602   /* GOT 15 bits offset.  */
1603   HOWTO2 (R_NDS32_GOT15S2_RELA, /* type  */
1604          2,                     /* rightshift  */
1605          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1606          15,                    /* bitsize  */
1607          FALSE,                 /* pc_relative  */
1608          0,                     /* bitpos  */
1609          complain_overflow_signed,/* complain_on_overflow  */
1610          bfd_elf_generic_reloc, /* special_function  */
1611          "R_NDS32_GOT15S2_RELA",/* name  */
1612          FALSE,                 /* partial_inplace  */
1613          0x00007fff,            /* src_mask  */
1614          0x00007fff,            /* dst_mask  */
1615          FALSE),                /* pcrel_offset  */
1616   /* GOT 17 bits offset.  */
1617   HOWTO2 (R_NDS32_GOT17S2_RELA, /* type  */
1618          2,                     /* rightshift  */
1619          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1620          17,                    /* bitsize  */
1621          FALSE,                 /* pc_relative  */
1622          0,                     /* bitpos  */
1623          complain_overflow_signed,/* complain_on_overflow  */
1624          bfd_elf_generic_reloc, /* special_function  */
1625          "R_NDS32_GOT17S2_RELA",/* name  */
1626          FALSE,                 /* partial_inplace  */
1627          0x0001ffff,            /* src_mask  */
1628          0x0001ffff,            /* dst_mask  */
1629          FALSE),                /* pcrel_offset  */
1630   /* A 5 bit address.  */
1631   HOWTO2 (R_NDS32_5_RELA,       /* type  */
1632          0,                     /* rightshift  */
1633          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1634          5,                     /* bitsize  */
1635          FALSE,                 /* pc_relative  */
1636          0,                     /* bitpos  */
1637          complain_overflow_signed,/* complain_on_overflow  */
1638          bfd_elf_generic_reloc, /* special_function  */
1639          "R_NDS32_5_RELA",      /* name  */
1640          FALSE,                 /* partial_inplace  */
1641          0x1f,                  /* src_mask  */
1642          0x1f,                  /* dst_mask  */
1643          FALSE),                /* pcrel_offset  */
1644   HOWTO2 (R_NDS32_10_UPCREL_RELA,/* type  */
1645          1,                     /* rightshift  */
1646          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1647          9,                     /* bitsize  */
1648          TRUE,                  /* pc_relative  */
1649          0,                     /* bitpos  */
1650          complain_overflow_unsigned,/* complain_on_overflow  */
1651          bfd_elf_generic_reloc, /* special_function  */
1652          "R_NDS32_10_UPCREL_RELA",/* name  */
1653          FALSE,                 /* partial_inplace  */
1654          0x1ff,                 /* src_mask  */
1655          0x1ff,                 /* dst_mask  */
1656          TRUE),                 /* pcrel_offset  */
1657   HOWTO2 (R_NDS32_SDA_FP7U2_RELA,/* type  */
1658          2,                     /* rightshift  */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1660          7,                     /* bitsize  */
1661          FALSE,                 /* pc_relative  */
1662          0,                     /* bitpos  */
1663          complain_overflow_unsigned,/* complain_on_overflow  */
1664          bfd_elf_generic_reloc, /* special_function  */
1665          "R_NDS32_SDA_FP7U2_RELA",/* name  */
1666          FALSE,                 /* partial_inplace  */
1667          0x0000007f,            /* src_mask  */
1668          0x0000007f,            /* dst_mask  */
1669          FALSE),                /* pcrel_offset  */
1670   HOWTO2 (R_NDS32_WORD_9_PCREL_RELA,/* type  */
1671          1,                     /* rightshift  */
1672          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1673          8,                     /* bitsize  */
1674          TRUE,                  /* pc_relative  */
1675          0,                     /* bitpos  */
1676          complain_overflow_signed,/* complain_on_overflow  */
1677          bfd_elf_generic_reloc, /* special_function  */
1678          "R_NDS32_WORD_9_PCREL_RELA",/* name  */
1679          FALSE,                 /* partial_inplace  */
1680          0xff,                  /* src_mask  */
1681          0xff,                  /* dst_mask  */
1682          TRUE),                 /* pcrel_offset  */
1683   HOWTO2 (R_NDS32_25_ABS_RELA,  /* type  */
1684          1,                     /* rightshift  */
1685          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1686          24,                    /* bitsize  */
1687          FALSE,                 /* pc_relative  */
1688          0,                     /* bitpos  */
1689          complain_overflow_dont,/* complain_on_overflow  */
1690          bfd_elf_generic_reloc, /* special_function  */
1691          "R_NDS32_25_ABS_RELA", /* name  */
1692          FALSE,                 /* partial_inplace  */
1693          0xffffff,              /* src_mask  */
1694          0xffffff,              /* dst_mask  */
1695          FALSE),                /* pcrel_offset  */
1696
1697   /* A relative 17 bit relocation for ifc, right shifted by 1.  */
1698   HOWTO2 (R_NDS32_17IFC_PCREL_RELA,/* type  */
1699          1,                     /* rightshift  */
1700          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1701          16,                    /* bitsize  */
1702          TRUE,                  /* pc_relative  */
1703          0,                     /* bitpos  */
1704          complain_overflow_signed,/* complain_on_overflow  */
1705          bfd_elf_generic_reloc, /* special_function  */
1706          "R_NDS32_17IFC_PCREL_RELA",/* name  */
1707          FALSE,                 /* partial_inplace  */
1708          0xffff,                /* src_mask  */
1709          0xffff,                /* dst_mask  */
1710          TRUE),                 /* pcrel_offset  */
1711
1712   /* A relative unsigned 10 bit relocation for ifc, right shifted by 1.  */
1713   HOWTO2 (R_NDS32_10IFCU_PCREL_RELA,/* type  */
1714          1,                     /* rightshift  */
1715          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1716          9,                     /* bitsize  */
1717          TRUE,                  /* pc_relative  */
1718          0,                     /* bitpos  */
1719          complain_overflow_unsigned,/* complain_on_overflow  */
1720          bfd_elf_generic_reloc, /* special_function  */
1721          "R_NDS32_10IFCU_PCREL_RELA",/* name  */
1722          FALSE,                 /* partial_inplace  */
1723          0x1ff,                 /* src_mask  */
1724          0x1ff,                 /* dst_mask  */
1725          TRUE),                 /* pcrel_offset  */
1726
1727   /* Like R_NDS32_HI20, but referring to the TLS LE entry for the symbol.  */
1728   HOWTO2 (R_NDS32_TLS_LE_HI20,  /* type  */
1729          12,                    /* rightshift  */
1730          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1731          20,                    /* bitsize  */
1732          FALSE,                 /* pc_relative  */
1733          0,                     /* bitpos  */
1734          complain_overflow_dont,/* complain_on_overflow  */
1735          bfd_elf_generic_reloc, /* special_function  */
1736          "R_NDS32_TLS_LE_HI20", /* name  */
1737          FALSE,                 /* partial_inplace  */
1738          0x000fffff,            /* src_mask  */
1739          0x000fffff,            /* dst_mask  */
1740          FALSE),                /* pcrel_offset  */
1741
1742   HOWTO2 (R_NDS32_TLS_LE_LO12,  /* type  */
1743          0,                     /* rightshift  */
1744          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1745          12,                    /* bitsize  */
1746          FALSE,                 /* pc_relative  */
1747          0,                     /* bitpos  */
1748          complain_overflow_dont,/* complain_on_overflow  */
1749          bfd_elf_generic_reloc, /* special_function  */
1750          "R_NDS32_TLS_LE_LO12", /* name  */
1751          FALSE,                 /* partial_inplace  */
1752          0x00000fff,            /* src_mask  */
1753          0x00000fff,            /* dst_mask  */
1754          FALSE),                /* pcrel_offset  */
1755
1756   /* Like R_NDS32_HI20, but referring to the TLS IE entry for the symbol.  */
1757   HOWTO2 (R_NDS32_TLS_IE_HI20,  /* type  */
1758          12,                    /* rightshift  */
1759          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1760          20,                    /* bitsize  */
1761          FALSE,                 /* pc_relative  */
1762          0,                     /* bitpos  */
1763          complain_overflow_dont,/* complain_on_overflow  */
1764          bfd_elf_generic_reloc, /* special_function  */
1765          "R_NDS32_TLS_IE_HI20", /* name  */
1766          FALSE,                 /* partial_inplace  */
1767          0x000fffff,            /* src_mask  */
1768          0x000fffff,            /* dst_mask  */
1769          FALSE),                /* pcrel_offset  */
1770
1771   HOWTO2 (R_NDS32_TLS_IE_LO12S2,/* type  */
1772          2,                     /* rightshift  */
1773          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1774          10,                    /* bitsize  */
1775          FALSE,                 /* pc_relative  */
1776          0,                     /* bitpos  */
1777          complain_overflow_dont,/* complain_on_overflow  */
1778          bfd_elf_generic_reloc, /* special_function  */
1779          "R_NDS32_TLS_IE_LO12S2",/* name  */
1780          FALSE,                 /* partial_inplace  */
1781          0x000003ff,            /* src_mask  */
1782          0x000003ff,            /* dst_mask  */
1783          FALSE),                /* pcrel_offset  */
1784
1785   /* TLS LE TP offset relocation  */
1786   HOWTO2 (R_NDS32_TLS_TPOFF,    /* type  */
1787          0,                     /* rightshift  */
1788          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1789          32,                    /* bitsize  */
1790          FALSE,                 /* pc_relative  */
1791          0,                     /* bitpos  */
1792          complain_overflow_bitfield,/* complain_on_overflow  */
1793          bfd_elf_generic_reloc, /* special_function  */
1794          "R_NDS32_TLS_TPOFF",   /* name  */
1795          FALSE,                 /* partial_inplace  */
1796          0xffffffff,            /* src_mask  */
1797          0xffffffff,            /* dst_mask  */
1798          FALSE),                /* pcrel_offset  */
1799
1800   /* A 20 bit address.  */
1801   HOWTO2 (R_NDS32_TLS_LE_20,    /* type  */
1802          0,                     /* rightshift  */
1803          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1804          20,                    /* bitsize  */
1805          FALSE,                 /* pc_relative  */
1806          0,                     /* bitpos  */
1807          complain_overflow_signed,/* complain_on_overflow  */
1808          bfd_elf_generic_reloc, /* special_function  */
1809          "R_NDS32_TLS_LE_20",   /* name  */
1810          FALSE,                 /* partial_inplace  */
1811          0xfffff,               /* src_mask  */
1812          0xfffff,               /* dst_mask  */
1813          FALSE),                /* pcrel_offset  */
1814
1815   HOWTO2 (R_NDS32_TLS_LE_15S0,  /* type  */
1816          0,                     /* rightshift  */
1817          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1818          15,                    /* bitsize  */
1819          FALSE,                 /* pc_relative  */
1820          0,                     /* bitpos  */
1821          complain_overflow_signed,/* complain_on_overflow  */
1822          bfd_elf_generic_reloc, /* special_function  */
1823          "R_NDS32_TLS_LE_15S0", /* name  */
1824          FALSE,                 /* partial_inplace  */
1825          0x7fff,                /* src_mask  */
1826          0x7fff,                /* dst_mask  */
1827          FALSE),                /* pcrel_offset  */
1828   HOWTO2 (R_NDS32_TLS_LE_15S1,  /* type  */
1829          1,                     /* rightshift  */
1830          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1831          15,                    /* bitsize  */
1832          FALSE,                 /* pc_relative  */
1833          0,                     /* bitpos  */
1834          complain_overflow_signed,/* complain_on_overflow  */
1835          bfd_elf_generic_reloc, /* special_function  */
1836          "R_NDS32_TLS_LE_15S1", /* name  */
1837          FALSE,                 /* partial_inplace  */
1838          0x7fff,                /* src_mask  */
1839          0x7fff,                /* dst_mask  */
1840          FALSE),                /* pcrel_offset  */
1841   HOWTO2 (R_NDS32_TLS_LE_15S2,  /* type  */
1842          2,                     /* rightshift  */
1843          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1844          15,                    /* bitsize  */
1845          FALSE,                 /* pc_relative  */
1846          0,                     /* bitpos  */
1847          complain_overflow_signed,/* complain_on_overflow  */
1848          bfd_elf_generic_reloc, /* special_function  */
1849          "R_NDS32_TLS_LE_15S2", /* name  */
1850          FALSE,                 /* partial_inplace  */
1851          0x7fff,                /* src_mask  */
1852          0x7fff,                /* dst_mask  */
1853          FALSE),                /* pcrel_offset  */
1854
1855   /* Relax hint for unconditional call sequence  */
1856   HOWTO2 (R_NDS32_LONGCALL4,    /* type  */
1857          0,                     /* rightshift  */
1858          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1859          32,                    /* bitsize  */
1860          FALSE,                 /* pc_relative  */
1861          0,                     /* bitpos  */
1862          complain_overflow_dont,/* complain_on_overflow  */
1863          nds32_elf_ignore_reloc,/* special_function  */
1864          "R_NDS32_LONGCALL4",   /* name  */
1865          FALSE,                 /* partial_inplace  */
1866          0xffffffff,            /* src_mask  */
1867          0xffffffff,            /* dst_mask  */
1868          FALSE),                /* pcrel_offset  */
1869
1870   /* Relax hint for conditional call sequence.  */
1871   HOWTO2 (R_NDS32_LONGCALL5,    /* type  */
1872          0,                     /* rightshift  */
1873          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1874          32,                    /* bitsize  */
1875          FALSE,                 /* pc_relative  */
1876          0,                     /* bitpos  */
1877          complain_overflow_dont,/* complain_on_overflow  */
1878          nds32_elf_ignore_reloc,/* special_function  */
1879          "R_NDS32_LONGCALL5",   /* name  */
1880          FALSE,                 /* partial_inplace  */
1881          0xffffffff,            /* src_mask  */
1882          0xffffffff,            /* dst_mask  */
1883          FALSE),                /* pcrel_offset  */
1884
1885   /* Relax hint for conditional call sequence.  */
1886   HOWTO2 (R_NDS32_LONGCALL6,    /* type  */
1887          0,                     /* rightshift  */
1888          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1889          32,                    /* bitsize  */
1890          FALSE,                 /* pc_relative  */
1891          0,                     /* bitpos  */
1892          complain_overflow_dont,/* complain_on_overflow  */
1893          nds32_elf_ignore_reloc,/* special_function  */
1894          "R_NDS32_LONGCALL6",   /* name  */
1895          FALSE,                 /* partial_inplace  */
1896          0xffffffff,            /* src_mask  */
1897          0xffffffff,            /* dst_mask  */
1898          FALSE),                /* pcrel_offset  */
1899
1900   /* Relax hint for unconditional branch sequence.  */
1901   HOWTO2 (R_NDS32_LONGJUMP4,    /* type  */
1902          0,                     /* rightshift  */
1903          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1904          32,                    /* bitsize  */
1905          FALSE,                 /* pc_relative  */
1906          0,                     /* bitpos  */
1907          complain_overflow_dont,/* complain_on_overflow  */
1908          nds32_elf_ignore_reloc,/* special_function  */
1909          "R_NDS32_LONGJUMP4",   /* name  */
1910          FALSE,                 /* partial_inplace  */
1911          0xffffffff,            /* src_mask  */
1912          0xffffffff,            /* dst_mask  */
1913          FALSE),                /* pcrel_offset  */
1914
1915   /* Relax hint for conditional branch sequence.  */
1916   HOWTO2 (R_NDS32_LONGJUMP5,    /* type  */
1917          0,                     /* rightshift  */
1918          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1919          32,                    /* bitsize  */
1920          FALSE,                 /* pc_relative  */
1921          0,                     /* bitpos  */
1922          complain_overflow_dont,/* complain_on_overflow  */
1923          nds32_elf_ignore_reloc,/* special_function  */
1924          "R_NDS32_LONGJUMP5",   /* name  */
1925          FALSE,                 /* partial_inplace  */
1926          0xffffffff,            /* src_mask  */
1927          0xffffffff,            /* dst_mask  */
1928          FALSE),                /* pcrel_offset  */
1929
1930   /* Relax hint for conditional branch sequence.  */
1931   HOWTO2 (R_NDS32_LONGJUMP6,    /* type  */
1932          0,                     /* rightshift  */
1933          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1934          32,                    /* bitsize  */
1935          FALSE,                 /* pc_relative  */
1936          0,                     /* bitpos  */
1937          complain_overflow_dont,/* complain_on_overflow  */
1938          nds32_elf_ignore_reloc,/* special_function  */
1939          "R_NDS32_LONGJUMP6",   /* name  */
1940          FALSE,                 /* partial_inplace  */
1941          0xffffffff,            /* src_mask  */
1942          0xffffffff,            /* dst_mask  */
1943          FALSE),                /* pcrel_offset  */
1944
1945   /* Relax hint for conditional branch sequence.  */
1946   HOWTO2 (R_NDS32_LONGJUMP7,    /* type  */
1947          0,                     /* rightshift  */
1948          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1949          32,                    /* bitsize  */
1950          FALSE,                 /* pc_relative  */
1951          0,                     /* bitpos  */
1952          complain_overflow_dont,/* complain_on_overflow  */
1953          nds32_elf_ignore_reloc,/* special_function  */
1954          "R_NDS32_LONGJUMP7",   /* name  */
1955          FALSE,                 /* partial_inplace  */
1956          0xffffffff,            /* src_mask  */
1957          0xffffffff,            /* dst_mask  */
1958          FALSE),                /* pcrel_offset  */
1959
1960   HOWTO2 (R_NDS32_TLS_IE_LO12,  /* type  */
1961          0,                     /* rightshift  */
1962          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1963          12,                    /* bitsize  */
1964          FALSE,                 /* pc_relative  */
1965          0,                     /* bitpos  */
1966          complain_overflow_dont,/* complain_on_overflow  */
1967          bfd_elf_generic_reloc, /* special_function  */
1968          "R_NDS32_TLS_IE_LO12", /* name  */
1969          FALSE,                 /* partial_inplace  */
1970          0x00000fff,            /* src_mask  */
1971          0x00000fff,            /* dst_mask  */
1972          FALSE),                /* pcrel_offset  */
1973
1974   /* Like R_NDS32_HI20, but referring to the TLS IE (PIE)
1975      entry for the symbol.  */
1976   HOWTO2 (R_NDS32_TLS_IEGP_HI20,/* type  */
1977          12,                    /* rightshift  */
1978          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1979          20,                    /* bitsize  */
1980          FALSE,                 /* pc_relative  */
1981          0,                     /* bitpos  */
1982          complain_overflow_dont,/* complain_on_overflow  */
1983          bfd_elf_generic_reloc, /* special_function  */
1984          "R_NDS32_TLS_IEGP_HI20",/* name  */
1985          FALSE,                 /* partial_inplace  */
1986          0x000fffff,            /* src_mask  */
1987          0x000fffff,            /* dst_mask  */
1988          FALSE),                /* pcrel_offset  */
1989
1990   HOWTO2 (R_NDS32_TLS_IEGP_LO12,/* type  */
1991          0,                     /* rightshift  */
1992          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1993          12,                    /* bitsize  */
1994          FALSE,                 /* pc_relative  */
1995          0,                     /* bitpos  */
1996          complain_overflow_dont,/* complain_on_overflow  */
1997          bfd_elf_generic_reloc, /* special_function  */
1998          "R_NDS32_TLS_IEGP_LO12",/* name  */
1999          FALSE,                 /* partial_inplace  */
2000          0x00000fff,            /* src_mask  */
2001          0x00000fff,            /* dst_mask  */
2002          FALSE),                /* pcrel_offset  */
2003
2004   HOWTO2 (R_NDS32_TLS_IEGP_LO12S2,/* type  */
2005          2,                     /* rightshift  */
2006          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2007          10,                    /* bitsize  */
2008          FALSE,                 /* pc_relative  */
2009          0,                     /* bitpos  */
2010          complain_overflow_dont,/* complain_on_overflow  */
2011          bfd_elf_generic_reloc, /* special_function  */
2012          "R_NDS32_TLS_IEGP_LO12S2",/* name  */
2013          FALSE,                 /* partial_inplace  */
2014          0x000003ff,            /* src_mask  */
2015          0x000003ff,            /* dst_mask  */
2016          FALSE),                /* pcrel_offset  */
2017
2018   /* TLS description relocation  */
2019   HOWTO2 (R_NDS32_TLS_DESC,     /* type  */
2020          12,                    /* rightshift  */
2021          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2022          20,                    /* bitsize  */
2023          FALSE,                 /* pc_relative  */
2024          0,                     /* bitpos  */
2025          complain_overflow_dont,/* complain_on_overflow  */
2026          nds32_elf_hi20_reloc,  /* special_function  */
2027          "R_NDS32_TLS_DESC_HI20",/* name  */
2028          FALSE,                 /* partial_inplace  */
2029          0x000fffff,            /* src_mask  */
2030          0x000fffff,            /* dst_mask  */
2031          FALSE),                /* pcrel_offset  */
2032
2033   /* TLS GD/LD description offset high part.  */
2034   HOWTO2 (R_NDS32_TLS_DESC_HI20,/* type  */
2035          12,                    /* rightshift  */
2036          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2037          20,                    /* bitsize  */
2038          FALSE,                 /* pc_relative  */
2039          0,                     /* bitpos  */
2040          complain_overflow_dont,/* complain_on_overflow  */
2041          nds32_elf_hi20_reloc,  /* special_function  */
2042          "R_NDS32_TLS_DESC_HI20",/* name  */
2043          FALSE,                 /* partial_inplace  */
2044          0x000fffff,            /* src_mask  */
2045          0x000fffff,            /* dst_mask  */
2046          FALSE),                /* pcrel_offset  */
2047
2048   /* TLS GD/LD description offset low part.  */
2049   HOWTO2 (R_NDS32_TLS_DESC_LO12,/* type  */
2050          0,                     /* rightshift  */
2051          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2052          12,                    /* bitsize  */
2053          FALSE,                 /* pc_relative  */
2054          0,                     /* bitpos  */
2055          complain_overflow_dont,/* complain_on_overflow  */
2056          nds32_elf_lo12_reloc,  /* special_function  */
2057          "R_NDS32_TLS_DESC_LO12",/* name  */
2058          FALSE,                 /* partial_inplace  */
2059          0x00000fff,            /* src_mask  */
2060          0x00000fff,            /* dst_mask  */
2061          FALSE),                /* pcrel_offset  */
2062
2063   /* TLS GD/LD description offset set (movi).  */
2064   HOWTO2 (R_NDS32_TLS_DESC_20,  /* type  */
2065          0,                     /* rightshift  */
2066          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2067          20,                    /* bitsize  */
2068          FALSE,                 /* pc_relative  */
2069          0,                     /* bitpos  */
2070          complain_overflow_signed,/* complain_on_overflow  */
2071          bfd_elf_generic_reloc, /* special_function  */
2072          "R_NDS32_TLS_DESC_20", /* name  */
2073          FALSE,                 /* partial_inplace  */
2074          0x000fffff,            /* src_mask  */
2075          0x000fffff,            /* dst_mask  */
2076          FALSE),                /* pcrel_offset  */
2077
2078   /* TLS GD/LD description offset set (lwi.gp).  */
2079   HOWTO2 (R_NDS32_TLS_DESC_SDA17S2,/* type  */
2080          2,                     /* rightshift  */
2081          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2082          17,                    /* bitsize  */
2083          FALSE,                 /* pc_relative  */
2084          0,                     /* bitpos  */
2085          complain_overflow_signed,/* complain_on_overflow  */
2086          bfd_elf_generic_reloc, /* special_function  */
2087          "R_NDS32_TLS_DESC_SDA17S2",/* name  */
2088          FALSE,                 /* partial_inplace  */
2089          0x0001ffff,            /* src_mask  */
2090          0x0001ffff,            /* dst_mask  */
2091          FALSE),                /* pcrel_offset  */
2092 };
2093
2094 /* Relocations used for relaxation.  */
2095 #define HOWTO3(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
2096   [C-R_NDS32_RELAX_ENTRY] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
2097
2098 static reloc_howto_type nds32_elf_relax_howto_table[] = {
2099   HOWTO3 (R_NDS32_RELAX_ENTRY,  /* type  */
2100          0,                     /* rightshift  */
2101          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2102          32,                    /* bitsize  */
2103          FALSE,                 /* pc_relative  */
2104          0,                     /* bitpos  */
2105          complain_overflow_dont,/* complain_on_overflow  */
2106          nds32_elf_ignore_reloc,/* special_function  */
2107          "R_NDS32_RELAX_ENTRY", /* name  */
2108          FALSE,                 /* partial_inplace  */
2109          0xffffffff,            /* src_mask  */
2110          0xffffffff,            /* dst_mask  */
2111          FALSE),                /* pcrel_offset  */
2112   HOWTO3 (R_NDS32_GOT_SUFF,     /* type  */
2113          0,                     /* rightshift  */
2114          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2115          32,                    /* bitsize  */
2116          FALSE,                 /* pc_relative  */
2117          0,                     /* bitpos  */
2118          complain_overflow_dont,/* complain_on_overflow  */
2119          nds32_elf_ignore_reloc,/* special_function  */
2120          "R_NDS32_GOT_SUFF",    /* name  */
2121          FALSE,                 /* partial_inplace  */
2122          0xffffffff,            /* src_mask  */
2123          0xffffffff,            /* dst_mask  */
2124          FALSE),                /* pcrel_offset  */
2125   HOWTO3 (R_NDS32_GOTOFF_SUFF,  /* type  */
2126          0,                     /* rightshift  */
2127          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2128          32,                    /* bitsize  */
2129          FALSE,                 /* pc_relative  */
2130          0,                     /* bitpos  */
2131          complain_overflow_bitfield,/* complain_on_overflow  */
2132          nds32_elf_ignore_reloc,/* special_function  */
2133          "R_NDS32_GOTOFF_SUFF", /* name  */
2134          FALSE,                 /* partial_inplace  */
2135          0xffffffff,            /* src_mask  */
2136          0xffffffff,            /* dst_mask  */
2137          FALSE),                /* pcrel_offset  */
2138   HOWTO3 (R_NDS32_PLT_GOT_SUFF, /* type  */
2139          0,                     /* rightshift  */
2140          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2141          32,                    /* bitsize  */
2142          FALSE,                 /* pc_relative  */
2143          0,                     /* bitpos  */
2144          complain_overflow_dont,/* complain_on_overflow  */
2145          nds32_elf_ignore_reloc,/* special_function  */
2146          "R_NDS32_PLT_GOT_SUFF",/* name  */
2147          FALSE,                 /* partial_inplace  */
2148          0xffffffff,            /* src_mask  */
2149          0xffffffff,            /* dst_mask  */
2150          FALSE),                /* pcrel_offset  */
2151   HOWTO3 (R_NDS32_MULCALL_SUFF, /* type  */
2152          0,                     /* rightshift  */
2153          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2154          32,                    /* bitsize  */
2155          FALSE,                 /* pc_relative  */
2156          0,                     /* bitpos  */
2157          complain_overflow_dont,/* complain_on_overflow  */
2158          nds32_elf_ignore_reloc,/* special_function  */
2159          "R_NDS32_MULCALL_SUFF",/* name  */
2160          FALSE,                 /* partial_inplace  */
2161          0xffffffff,            /* src_mask  */
2162          0xffffffff,            /* dst_mask  */
2163          FALSE),                /* pcrel_offset  */
2164   HOWTO3 (R_NDS32_PTR,          /* type  */
2165          0,                     /* rightshift  */
2166          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2167          32,                    /* bitsize  */
2168          FALSE,                 /* pc_relative  */
2169          0,                     /* bitpos  */
2170          complain_overflow_dont,/* complain_on_overflow  */
2171          nds32_elf_ignore_reloc,/* special_function  */
2172          "R_NDS32_PTR",         /* name  */
2173          FALSE,                 /* partial_inplace  */
2174          0xffffffff,            /* src_mask  */
2175          0xffffffff,            /* dst_mask  */
2176          FALSE),                /* pcrel_offset  */
2177   HOWTO3 (R_NDS32_PTR_COUNT,    /* type  */
2178          0,                     /* rightshift  */
2179          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2180          32,                    /* bitsize  */
2181          FALSE,                 /* pc_relative  */
2182          0,                     /* bitpos  */
2183          complain_overflow_dont,/* complain_on_overflow  */
2184          nds32_elf_ignore_reloc,/* special_function  */
2185          "R_NDS32_PTR_COUNT",   /* name  */
2186          FALSE,                 /* partial_inplace  */
2187          0xffffffff,            /* src_mask  */
2188          0xffffffff,            /* dst_mask  */
2189          FALSE),                /* pcrel_offset  */
2190   HOWTO3 (R_NDS32_PTR_RESOLVED, /* type  */
2191          0,                     /* rightshift  */
2192          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2193          32,                    /* bitsize  */
2194          FALSE,                 /* pc_relative  */
2195          0,                     /* bitpos  */
2196          complain_overflow_dont,/* complain_on_overflow  */
2197          nds32_elf_ignore_reloc,/* special_function  */
2198          "R_NDS32_PTR_RESOLVED",/* name  */
2199          FALSE,                 /* partial_inplace  */
2200          0xffffffff,            /* src_mask  */
2201          0xffffffff,            /* dst_mask  */
2202          FALSE),                /* pcrel_offset  */
2203   HOWTO3 (R_NDS32_PLTBLOCK,     /* type  */
2204          0,                     /* rightshift  */
2205          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2206          32,                    /* bitsize  */
2207          FALSE,                 /* pc_relative  */
2208          0,                     /* bitpos  */
2209          complain_overflow_dont,/* complain_on_overflow  */
2210          nds32_elf_ignore_reloc,/* special_function  */
2211          "R_NDS32_PLTBLOCK",    /* name  */
2212          FALSE,                 /* partial_inplace  */
2213          0xffffffff,            /* src_mask  */
2214          0xffffffff,            /* dst_mask  */
2215          FALSE),                /* pcrel_offset  */
2216   HOWTO3 (R_NDS32_RELAX_REGION_BEGIN,/* type  */
2217          0,                     /* rightshift  */
2218          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2219          32,                    /* bitsize  */
2220          FALSE,                 /* pc_relative  */
2221          0,                     /* bitpos  */
2222          complain_overflow_dont,/* complain_on_overflow  */
2223          nds32_elf_ignore_reloc,/* special_function  */
2224          "R_NDS32_RELAX_REGION_BEGIN",/* name  */
2225          FALSE,                 /* partial_inplace  */
2226          0xffffffff,            /* src_mask  */
2227          0xffffffff,            /* dst_mask  */
2228          FALSE),                /* pcrel_offset  */
2229   HOWTO3 (R_NDS32_RELAX_REGION_END,/* type  */
2230          0,                     /* rightshift  */
2231          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2232          32,                    /* bitsize  */
2233          FALSE,                 /* pc_relative  */
2234          0,                     /* bitpos  */
2235          complain_overflow_dont,/* complain_on_overflow  */
2236          nds32_elf_ignore_reloc,/* special_function  */
2237          "R_NDS32_RELAX_REGION_END",/* name  */
2238          FALSE,                 /* partial_inplace  */
2239          0xffffffff,            /* src_mask  */
2240          0xffffffff,            /* dst_mask  */
2241          FALSE),                /* pcrel_offset  */
2242   HOWTO3 (R_NDS32_MINUEND,      /* type  */
2243          0,                     /* rightshift  */
2244          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2245          32,                    /* bitsize  */
2246          FALSE,                 /* pc_relative  */
2247          0,                     /* bitpos  */
2248          complain_overflow_dont,/* complain_on_overflow  */
2249          nds32_elf_ignore_reloc,/* special_function  */
2250          "R_NDS32_MINUEND",     /* name  */
2251          FALSE,                 /* partial_inplace  */
2252          0xffffffff,            /* src_mask  */
2253          0xffffffff,            /* dst_mask  */
2254          FALSE),                /* pcrel_offset  */
2255   HOWTO3 (R_NDS32_SUBTRAHEND,   /* type  */
2256          0,                     /* rightshift  */
2257          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2258          32,                    /* bitsize  */
2259          FALSE,                 /* pc_relative  */
2260          0,                     /* bitpos  */
2261          complain_overflow_dont,/* complain_on_overflow  */
2262          nds32_elf_ignore_reloc,/* special_function  */
2263          "R_NDS32_SUBTRAHEND",  /* name  */
2264          FALSE,                 /* partial_inplace  */
2265          0xffffffff,            /* src_mask  */
2266          0xffffffff,            /* dst_mask  */
2267          FALSE),                /* pcrel_offset  */
2268   HOWTO3 (R_NDS32_DIFF8,        /* type  */
2269          0,                     /* rightshift  */
2270          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
2271          8,                     /* bitsize  */
2272          FALSE,                 /* pc_relative  */
2273          0,                     /* bitpos  */
2274          complain_overflow_dont,/* complain_on_overflow  */
2275          nds32_elf_ignore_reloc,/* special_function  */
2276          "R_NDS32_DIFF8",       /* name  */
2277          FALSE,                 /* partial_inplace  */
2278          0x000000ff,            /* src_mask  */
2279          0x000000ff,            /* dst_mask  */
2280          FALSE),                /* pcrel_offset  */
2281   HOWTO3 (R_NDS32_DIFF16,       /* type  */
2282          0,                     /* rightshift  */
2283          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
2284          16,                    /* bitsize  */
2285          FALSE,                 /* pc_relative  */
2286          0,                     /* bitpos  */
2287          complain_overflow_dont,/* complain_on_overflow  */
2288          nds32_elf_ignore_reloc,/* special_function  */
2289          "R_NDS32_DIFF16",      /* name  */
2290          FALSE,                 /* partial_inplace  */
2291          0x0000ffff,            /* src_mask  */
2292          0x0000ffff,            /* dst_mask  */
2293          FALSE),                /* pcrel_offset  */
2294   HOWTO3 (R_NDS32_DIFF32,       /* type  */
2295          0,                     /* rightshift  */
2296          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2297          32,                    /* bitsize  */
2298          FALSE,                 /* pc_relative  */
2299          0,                     /* bitpos  */
2300          complain_overflow_dont,/* complain_on_overflow  */
2301          nds32_elf_ignore_reloc,/* special_function  */
2302          "R_NDS32_DIFF32",      /* name  */
2303          FALSE,                 /* partial_inplace  */
2304          0xffffffff,            /* src_mask  */
2305          0xffffffff,            /* dst_mask  */
2306          FALSE),                /* pcrel_offset  */
2307   HOWTO3 (R_NDS32_DIFF_ULEB128, /* type  */
2308          0,                     /* rightshift  */
2309          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
2310          0,                     /* bitsize  */
2311          FALSE,                 /* pc_relative  */
2312          0,                     /* bitpos  */
2313          complain_overflow_dont,/* complain_on_overflow  */
2314          nds32_elf_ignore_reloc,/* special_function  */
2315          "R_NDS32_DIFF_ULEB128",/* name  */
2316          FALSE,                 /* partial_inplace  */
2317          0xffffffff,            /* src_mask  */
2318          0xffffffff,            /* dst_mask  */
2319          FALSE),                /* pcrel_offset  */
2320   HOWTO3 (R_NDS32_DATA,         /* type  */
2321          0,                     /* rightshift  */
2322          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2323          32,                    /* bitsize  */
2324          FALSE,                 /* pc_relative  */
2325          0,                     /* bitpos  */
2326          complain_overflow_dont,/* complain_on_overflow  */
2327          nds32_elf_ignore_reloc,/* special_function  */
2328          "R_NDS32_DATA",        /* name  */
2329          FALSE,                 /* partial_inplace  */
2330          0xffffffff,            /* src_mask  */
2331          0xffffffff,            /* dst_mask  */
2332          FALSE),                /* pcrel_offset  */
2333   HOWTO3 (R_NDS32_TRAN,         /* type  */
2334          0,                     /* rightshift  */
2335          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2336          32,                    /* bitsize  */
2337          FALSE,                 /* pc_relative  */
2338          0,                     /* bitpos  */
2339          complain_overflow_dont,/* complain_on_overflow  */
2340          nds32_elf_ignore_reloc,/* special_function  */
2341          "R_NDS32_TRAN",        /* name  */
2342          FALSE,                 /* partial_inplace  */
2343          0xffffffff,            /* src_mask  */
2344          0xffffffff,            /* dst_mask  */
2345          FALSE),                /* pcrel_offset  */
2346   HOWTO3 (R_NDS32_TLS_LE_ADD,   /* type  */
2347          0,                     /* rightshift  */
2348          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2349          32,                    /* bitsize  */
2350          FALSE,                 /* pc_relative  */
2351          0,                     /* bitpos  */
2352          complain_overflow_dont,/* complain_on_overflow  */
2353          nds32_elf_ignore_reloc,/* special_function  */
2354          "R_NDS32_TLS_LE_ADD",  /* name  */
2355          FALSE,                 /* partial_inplace  */
2356          0xffffffff,            /* src_mask  */
2357          0xffffffff,            /* dst_mask  */
2358          FALSE),                /* pcrel_offset  */
2359   HOWTO3 (R_NDS32_TLS_LE_LS,    /* type  */
2360          0,                     /* rightshift  */
2361          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2362          32,                    /* bitsize  */
2363          FALSE,                 /* pc_relative  */
2364          0,                     /* bitpos  */
2365          complain_overflow_dont,/* complain_on_overflow  */
2366          nds32_elf_ignore_reloc,/* special_function  */
2367          "R_NDS32_TLS_LE_LS",   /* name  */
2368          FALSE,                 /* partial_inplace  */
2369          0xffffffff,            /* src_mask  */
2370          0xffffffff,            /* dst_mask  */
2371          FALSE),                /* pcrel_offset  */
2372   HOWTO3 (R_NDS32_EMPTY,        /* type  */
2373          0,                     /* rightshift  */
2374          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2375          32,                    /* bitsize  */
2376          FALSE,                 /* pc_relative  */
2377          0,                     /* bitpos  */
2378          complain_overflow_dont,/* complain_on_overflow  */
2379          nds32_elf_ignore_reloc,/* special_function  */
2380          "R_NDS32_EMPTY",       /* name  */
2381          FALSE,                 /* partial_inplace  */
2382          0xffffffff,            /* src_mask  */
2383          0xffffffff,            /* dst_mask  */
2384          FALSE),                /* pcrel_offset  */
2385   /* TLS GD/LD description address base addition.  */
2386   HOWTO3 (R_NDS32_TLS_DESC_ADD, /* type  */
2387          0,                     /* rightshift  */
2388          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2389          32,                    /* bitsize  */
2390          FALSE,                 /* pc_relative  */
2391          0,                     /* bitpos  */
2392          complain_overflow_dont,/* complain_on_overflow  */
2393          nds32_elf_ignore_reloc,/* special_function  */
2394          "R_NDS32_TLS_DESC_ADD",/* name  */
2395          FALSE,                 /* partial_inplace  */
2396          0xffffffff,            /* src_mask  */
2397          0xffffffff,            /* dst_mask  */
2398          FALSE),                /* pcrel_offset  */
2399   /* TLS GD/LD description function load.  */
2400   HOWTO3 (R_NDS32_TLS_DESC_FUNC,/* type  */
2401          0,                     /* rightshift  */
2402          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2403          32,                    /* bitsize  */
2404          FALSE,                 /* pc_relative  */
2405          0,                     /* bitpos  */
2406          complain_overflow_dont,/* complain_on_overflow  */
2407          nds32_elf_ignore_reloc,/* special_function  */
2408          "R_NDS32_TLS_DESC_FUNC",/* name  */
2409          FALSE,                 /* partial_inplace  */
2410          0xffffffff,            /* src_mask  */
2411          0xffffffff,            /* dst_mask  */
2412          FALSE),                /* pcrel_offset  */
2413   /* TLS DESC resolve function call.  */
2414   HOWTO3 (R_NDS32_TLS_DESC_CALL,/* type  */
2415          0,                     /* rightshift  */
2416          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2417          32,                    /* bitsize  */
2418          FALSE,                 /* pc_relative  */
2419          0,                     /* bitpos  */
2420          complain_overflow_dont,/* complain_on_overflow  */
2421          nds32_elf_ignore_reloc,/* special_function  */
2422          "R_NDS32_TLS_DESC_CALL",/* name  */
2423          FALSE,                 /* partial_inplace  */
2424          0xffffffff,            /* src_mask  */
2425          0xffffffff,            /* dst_mask  */
2426          FALSE),                /* pcrel_offset  */
2427   /* TLS DESC variable access.  */
2428   HOWTO3 (R_NDS32_TLS_DESC_MEM, /* type  */
2429          0,                     /* rightshift  */
2430          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2431          32,                    /* bitsize  */
2432          FALSE,                 /* pc_relative  */
2433          0,                     /* bitpos  */
2434          complain_overflow_dont,/* complain_on_overflow  */
2435          nds32_elf_ignore_reloc,/* special_function  */
2436          "R_NDS32_TLS_DESC_MEM",/* name  */
2437          FALSE,                 /* partial_inplace  */
2438          0xffffffff,            /* src_mask  */
2439          0xffffffff,            /* dst_mask  */
2440          FALSE),                /* pcrel_offset  */
2441   /* TLS GD/LD description mark (@tlsdec).  */
2442   HOWTO3 (R_NDS32_RELAX_REMOVE, /* type  */
2443          0,                     /* rightshift  */
2444          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2445          32,                    /* bitsize  */
2446          FALSE,                 /* pc_relative  */
2447          0,                     /* bitpos  */
2448          complain_overflow_dont,/* complain_on_overflow  */
2449          nds32_elf_ignore_reloc,/* special_function  */
2450          "R_NDS32_REMOVE",      /* name  */
2451          FALSE,                 /* partial_inplace  */
2452          0xffffffff,            /* src_mask  */
2453          0xffffffff,            /* dst_mask  */
2454          FALSE),                /* pcrel_offset  */
2455   /* TLS GD/LD description mark (@tlsdec).  */
2456   HOWTO3 (R_NDS32_RELAX_GROUP,  /* type  */
2457          0,                     /* rightshift  */
2458          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2459          32,                    /* bitsize  */
2460          FALSE,                 /* pc_relative  */
2461          0,                     /* bitpos  */
2462          complain_overflow_dont,/* complain_on_overflow  */
2463          nds32_elf_ignore_reloc,/* special_function  */
2464          "R_NDS32_GROUP",       /* name  */
2465          FALSE,                 /* partial_inplace  */
2466          0xffffffff,            /* src_mask  */
2467          0xffffffff,            /* dst_mask  */
2468          FALSE),                /* pcrel_offset  */
2469   HOWTO3 (R_NDS32_TLS_IEGP_LW,  /* type  */
2470          0,                     /* rightshift  */
2471          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2472          32,                    /* bitsize  */
2473          FALSE,                 /* pc_relative  */
2474          0,                     /* bitpos  */
2475          complain_overflow_dont,/* complain_on_overflow  */
2476          nds32_elf_ignore_reloc,/* special_function  */
2477          "R_NDS32_TLS_IEGP_LW", /* name  */
2478          FALSE,                 /* partial_inplace  */
2479          0xffffffff,            /* src_mask  */
2480          0xffffffff,            /* dst_mask  */
2481          FALSE),                /* pcrel_offset  */
2482   /* LA and FLSI relaxation.  */
2483   HOWTO3 (R_NDS32_LSI,          /* type  */
2484          0,                     /* rightshift  */
2485          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2486          32,                    /* bitsize  */
2487          FALSE,                 /* pc_relative  */
2488          0,                     /* bitpos  */
2489          complain_overflow_dont,/* complain_on_overflow  */
2490          nds32_elf_ignore_reloc,/* special_function  */
2491          "R_NDS32_LSI",         /* name  */
2492          FALSE,                 /* partial_inplace  */
2493          0xffffffff,            /* src_mask  */
2494          0xffffffff,            /* dst_mask  */
2495          FALSE),
2496 };
2497
2498 static unsigned long dl_tlsdesc_lazy_trampoline[] =
2499 {
2500   0x46200000,                   /* sethi $r2,#0x0      */
2501   0x58210000,                   /* ori $r2,$r2,#0x0    */
2502   0x40217400,                   /* add $r2,$r2,$gp     */
2503   0x04210000,                   /* lwi $r2,[$r2+#0x0]  */
2504   0x46300000,                   /* sethi $r3,#0x0      */
2505   0x58318000,                   /* ori $r3,$r3,#0x0    */
2506   0x4031f400,                   /* add $r3,$r3,$gp     */
2507   0x4a000800,                   /* jr $r2              */
2508 };
2509
2510 static void
2511 nds32_put_trampoline (void *contents, const unsigned long *template,
2512                       unsigned count)
2513 {
2514   unsigned ix;
2515
2516   for (ix = 0; ix != count; ix++)
2517     {
2518       unsigned long insn = template[ix];
2519       bfd_putb32 (insn, (char *) contents + ix * 4);
2520     }
2521 }
2522
2523 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2524    This prototype is the same as qsort ().  */
2525
2526 void
2527 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2528                       int (*compar) (const void *lhs, const void *rhs))
2529 {
2530   char *ptr = (char *) base;
2531   int i, j;
2532   char tmp[sizeof (Elf_Internal_Rela)];
2533
2534   BFD_ASSERT (size <= sizeof (tmp));
2535
2536   /* If i is less than j, i is inserted before j.
2537
2538      |---- j ----- i --------------|
2539       \          / \              /
2540          sorted         unsorted
2541    */
2542
2543   for (i = 1; i < (int) nmemb; i++)
2544     {
2545       for (j = (i - 1); j >= 0; j--)
2546         if (compar (ptr + i * size, ptr + j * size) >= 0)
2547           break;
2548
2549       j++;
2550
2551       if (i == j)
2552         continue; /* i is in order.  */
2553
2554       memcpy (tmp, ptr + i * size, size);
2555       memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2556       memcpy (ptr + j * size, tmp, size);
2557     }
2558 }
2559
2560 /* Sort relocation by r_offset.
2561
2562    We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2563    algorithm.  Relocations at the same r_offset must keep their order.
2564    For example, RELAX_ENTRY must be the very first relocation entry.
2565
2566    Currently, this function implements insertion-sort.
2567
2568    FIXME: If we already sort them in assembler, why bother sort them
2569           here again?  */
2570
2571 static int
2572 compar_reloc (const void *lhs, const void *rhs)
2573 {
2574   const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2575   const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2576
2577   if (l->r_offset > r->r_offset)
2578     return 1;
2579   else if (l->r_offset == r->r_offset)
2580     return 0;
2581   else
2582     return -1;
2583 }
2584
2585 /* Functions listed below are only used for old relocs.
2586      nds32_elf_9_pcrel_reloc
2587      nds32_elf_do_9_pcrel_reloc
2588      nds32_elf_hi20_reloc
2589      nds32_elf_relocate_hi20
2590      nds32_elf_lo12_reloc
2591      nds32_elf_sda15_reloc
2592      nds32_elf_generic_reloc.  */
2593
2594 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc.  */
2595
2596 static bfd_reloc_status_type
2597 nds32_elf_9_pcrel_reloc (bfd *       abfd,
2598                          arelent *   reloc_entry,
2599                          asymbol *   symbol,
2600                          void *      data,
2601                          asection *  input_section,
2602                          bfd *       output_bfd,
2603                          char **     error_message ATTRIBUTE_UNUSED)
2604 {
2605   /* This part is from bfd_elf_generic_reloc.  */
2606   if (output_bfd != (bfd *) NULL
2607       && (symbol->flags & BSF_SECTION_SYM) == 0
2608       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2609     {
2610       reloc_entry->address += input_section->output_offset;
2611       return bfd_reloc_ok;
2612     }
2613
2614   if (output_bfd != NULL)
2615     {
2616       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2617       return bfd_reloc_continue;
2618     }
2619
2620   return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2621                                      input_section,
2622                                      data, reloc_entry->address,
2623                                      symbol->section,
2624                                      (symbol->value
2625                                       + symbol->section->output_section->vma
2626                                       + symbol->section->output_offset),
2627                                      reloc_entry->addend);
2628 }
2629
2630 /* Utility to actually perform an R_NDS32_9_PCREL reloc.  */
2631 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2632
2633 static bfd_reloc_status_type
2634 nds32_elf_do_9_pcrel_reloc (bfd *               abfd,
2635                             reloc_howto_type *  howto,
2636                             asection *          input_section,
2637                             bfd_byte *          data,
2638                             bfd_vma             offset,
2639                             asection *          symbol_section ATTRIBUTE_UNUSED,
2640                             bfd_vma             symbol_value,
2641                             bfd_vma             addend)
2642 {
2643   bfd_signed_vma relocation;
2644   unsigned short x;
2645   bfd_reloc_status_type status;
2646
2647   /* Sanity check the address (offset in section).  */
2648   if (offset > bfd_get_section_limit (abfd, input_section))
2649     return bfd_reloc_outofrange;
2650
2651   relocation = symbol_value + addend;
2652   /* Make it pc relative.  */
2653   relocation -= (input_section->output_section->vma
2654                  + input_section->output_offset);
2655   /* These jumps mask off the lower two bits of the current address
2656      before doing pcrel calculations.  */
2657   relocation -= (offset & -(bfd_vma) 2);
2658
2659   if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2660     status = bfd_reloc_overflow;
2661   else
2662     status = bfd_reloc_ok;
2663
2664   x = bfd_getb16 (data + offset);
2665
2666   relocation >>= howto->rightshift;
2667   relocation <<= howto->bitpos;
2668   x = (x & ~howto->dst_mask)
2669       | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2670
2671   bfd_putb16 ((bfd_vma) x, data + offset);
2672
2673   return status;
2674 }
2675
2676 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2677    HI20_SLO is for the add3 and load/store with displacement instructions.
2678    HI20 is for the or3 instruction.
2679    For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2680    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2681    we must add one to the high 16 bytes (which will get subtracted off when
2682    the low 16 bits are added).
2683    These relocs have to be done in combination with an R_NDS32_LO12 reloc
2684    because there is a carry from the LO12 to the HI20.  Here we just save
2685    the information we need; we do the actual relocation when we see the LO12.
2686    This code is copied from the elf32-mips.c.  We also support an arbitrary
2687    number of HI20 relocs to be associated with a single LO12 reloc.  The
2688    assembler sorts the relocs to ensure each HI20 immediately precedes its
2689    LO12.  However if there are multiple copies, the assembler may not find
2690    the real LO12 so it picks the first one it finds.  */
2691
2692 struct nds32_hi20
2693 {
2694   struct nds32_hi20 *next;
2695   bfd_byte *addr;
2696   bfd_vma addend;
2697 };
2698
2699 static struct nds32_hi20 *nds32_hi20_list;
2700
2701 static bfd_reloc_status_type
2702 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2703                       arelent *reloc_entry,
2704                       asymbol *symbol,
2705                       void *data,
2706                       asection *input_section,
2707                       bfd *output_bfd,
2708                       char **error_message ATTRIBUTE_UNUSED)
2709 {
2710   bfd_reloc_status_type ret;
2711   bfd_vma relocation;
2712   struct nds32_hi20 *n;
2713
2714   /* This part is from bfd_elf_generic_reloc.
2715      If we're relocating, and this an external symbol, we don't want
2716      to change anything.  */
2717   if (output_bfd != (bfd *) NULL
2718       && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2719     {
2720       reloc_entry->address += input_section->output_offset;
2721       return bfd_reloc_ok;
2722     }
2723
2724   /* Sanity check the address (offset in section).  */
2725   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2726     return bfd_reloc_outofrange;
2727
2728   ret = bfd_reloc_ok;
2729   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2730     ret = bfd_reloc_undefined;
2731
2732   if (bfd_is_com_section (symbol->section))
2733     relocation = 0;
2734   else
2735     relocation = symbol->value;
2736
2737   relocation += symbol->section->output_section->vma;
2738   relocation += symbol->section->output_offset;
2739   relocation += reloc_entry->addend;
2740
2741   /* Save the information, and let LO12 do the actual relocation.  */
2742   n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2743   if (n == NULL)
2744     return bfd_reloc_outofrange;
2745
2746   n->addr = (bfd_byte *) data + reloc_entry->address;
2747   n->addend = relocation;
2748   n->next = nds32_hi20_list;
2749   nds32_hi20_list = n;
2750
2751   if (output_bfd != (bfd *) NULL)
2752     reloc_entry->address += input_section->output_offset;
2753
2754   return ret;
2755 }
2756
2757 /* Handle an NDS32 ELF HI20 reloc.  */
2758
2759 static void
2760 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2761                          int type ATTRIBUTE_UNUSED,
2762                          Elf_Internal_Rela *relhi,
2763                          Elf_Internal_Rela *rello,
2764                          bfd_byte *contents,
2765                          bfd_vma addend)
2766 {
2767   unsigned long insn;
2768   bfd_vma addlo;
2769
2770   insn = bfd_getb32 (contents + relhi->r_offset);
2771
2772   addlo = bfd_getb32 (contents + rello->r_offset);
2773   addlo &= 0xfff;
2774
2775   addend += ((insn & 0xfffff) << 20) + addlo;
2776
2777   insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2778   bfd_putb32 (insn, contents + relhi->r_offset);
2779 }
2780
2781 /* Do an R_NDS32_LO12 relocation.  This is a straightforward 12 bit
2782    inplace relocation; this function exists in order to do the
2783    R_NDS32_HI20_[SU]LO relocation described above.  */
2784
2785 static bfd_reloc_status_type
2786 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2787                       void *data, asection *input_section, bfd *output_bfd,
2788                       char **error_message)
2789 {
2790   /* This part is from bfd_elf_generic_reloc.
2791      If we're relocating, and this an external symbol, we don't want
2792      to change anything.  */
2793   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2794       && reloc_entry->addend == 0)
2795     {
2796       reloc_entry->address += input_section->output_offset;
2797       return bfd_reloc_ok;
2798     }
2799
2800   if (nds32_hi20_list != NULL)
2801     {
2802       struct nds32_hi20 *l;
2803
2804       l = nds32_hi20_list;
2805       while (l != NULL)
2806         {
2807           unsigned long insn;
2808           unsigned long val;
2809           unsigned long vallo;
2810           struct nds32_hi20 *next;
2811
2812           /* Do the HI20 relocation.  Note that we actually don't need
2813              to know anything about the LO12 itself, except where to
2814              find the low 12 bits of the addend needed by the LO12.  */
2815           insn = bfd_getb32 (l->addr);
2816           vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2817           vallo &= 0xfff;
2818           switch (reloc_entry->howto->type)
2819             {
2820             case R_NDS32_LO12S3:
2821               vallo <<= 3;
2822               break;
2823
2824             case R_NDS32_LO12S2:
2825               vallo <<= 2;
2826               break;
2827
2828             case R_NDS32_LO12S1:
2829               vallo <<= 1;
2830               break;
2831
2832             case R_NDS32_LO12S0:
2833               vallo <<= 0;
2834               break;
2835             }
2836
2837           val = ((insn & 0xfffff) << 12) + vallo;
2838           val += l->addend;
2839
2840           insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2841           bfd_putb32 ((bfd_vma) insn, l->addr);
2842
2843           next = l->next;
2844           free (l);
2845           l = next;
2846         }
2847
2848       nds32_hi20_list = NULL;
2849     }
2850
2851   /* Now do the LO12 reloc in the usual way.
2852      ??? It would be nice to call bfd_elf_generic_reloc here,
2853      but we have partial_inplace set.  bfd_elf_generic_reloc will
2854      pass the handling back to bfd_install_relocation which will install
2855      a section relative addend which is wrong.  */
2856   return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2857                                   input_section, output_bfd, error_message);
2858 }
2859
2860 /* Do generic partial_inplace relocation.
2861    This is a local replacement for bfd_elf_generic_reloc.  */
2862
2863 static bfd_reloc_status_type
2864 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2865                          asymbol *symbol, void *data, asection *input_section,
2866                          bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2867 {
2868   bfd_reloc_status_type ret;
2869   bfd_vma relocation;
2870   bfd_byte *inplace_address;
2871
2872   /* This part is from bfd_elf_generic_reloc.
2873      If we're relocating, and this an external symbol, we don't want
2874      to change anything.  */
2875   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2876       && reloc_entry->addend == 0)
2877     {
2878       reloc_entry->address += input_section->output_offset;
2879       return bfd_reloc_ok;
2880     }
2881
2882   /* Now do the reloc in the usual way.
2883      ??? It would be nice to call bfd_elf_generic_reloc here,
2884      but we have partial_inplace set.  bfd_elf_generic_reloc will
2885      pass the handling back to bfd_install_relocation which will install
2886      a section relative addend which is wrong.  */
2887
2888   /* Sanity check the address (offset in section).  */
2889   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2890     return bfd_reloc_outofrange;
2891
2892   ret = bfd_reloc_ok;
2893   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2894     ret = bfd_reloc_undefined;
2895
2896   if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2897     relocation = 0;
2898   else
2899     relocation = symbol->value;
2900
2901   /* Only do this for a final link.  */
2902   if (output_bfd == (bfd *) NULL)
2903     {
2904       relocation += symbol->section->output_section->vma;
2905       relocation += symbol->section->output_offset;
2906     }
2907
2908   relocation += reloc_entry->addend;
2909   switch (reloc_entry->howto->type)
2910     {
2911     case R_NDS32_LO12S3:
2912       relocation >>= 3;
2913       break;
2914
2915     case R_NDS32_LO12S2:
2916       relocation >>= 2;
2917       break;
2918
2919     case R_NDS32_LO12S1:
2920       relocation >>= 1;
2921       break;
2922
2923     case R_NDS32_LO12S0:
2924     default:
2925       relocation >>= 0;
2926       break;
2927     }
2928
2929   inplace_address = (bfd_byte *) data + reloc_entry->address;
2930
2931 #define DOIT(x)                                         \
2932   x = ((x & ~reloc_entry->howto->dst_mask) |            \
2933   (((x & reloc_entry->howto->src_mask) +  relocation) & \
2934   reloc_entry->howto->dst_mask))
2935
2936   switch (reloc_entry->howto->size)
2937     {
2938     case 1:
2939       {
2940         short x = bfd_getb16 (inplace_address);
2941
2942         DOIT (x);
2943         bfd_putb16 ((bfd_vma) x, inplace_address);
2944       }
2945       break;
2946     case 2:
2947       {
2948         unsigned long x = bfd_getb32 (inplace_address);
2949
2950         DOIT (x);
2951         bfd_putb32 ((bfd_vma) x, inplace_address);
2952       }
2953       break;
2954     default:
2955       BFD_ASSERT (0);
2956     }
2957
2958   if (output_bfd != (bfd *) NULL)
2959     reloc_entry->address += input_section->output_offset;
2960
2961   return ret;
2962 }
2963
2964 /* Handle the R_NDS32_SDA15 reloc.
2965    This reloc is used to compute the address of objects in the small data area
2966    and to perform loads and stores from that area.
2967    The lower 15 bits are sign extended and added to the register specified
2968    in the instruction, which is assumed to point to _SDA_BASE_.
2969
2970    Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2971    the access size, this must be taken care of.  */
2972
2973 static bfd_reloc_status_type
2974 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2975                        asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2976                        asection *input_section, bfd *output_bfd,
2977                        char **error_message ATTRIBUTE_UNUSED)
2978 {
2979   /* This part is from bfd_elf_generic_reloc.  */
2980   if (output_bfd != (bfd *) NULL
2981       && (symbol->flags & BSF_SECTION_SYM) == 0
2982       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2983     {
2984       reloc_entry->address += input_section->output_offset;
2985       return bfd_reloc_ok;
2986     }
2987
2988   if (output_bfd != NULL)
2989     {
2990       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2991       return bfd_reloc_continue;
2992     }
2993
2994   /* FIXME: not sure what to do here yet.  But then again, the linker
2995      may never call us.  */
2996   abort ();
2997 }
2998
2999 /* nds32_elf_ignore_reloc is the special function for
3000    relocation types which don't need to be relocated
3001    like relaxation relocation types.
3002    This function simply return bfd_reloc_ok when it is
3003    invoked.  */
3004
3005 static bfd_reloc_status_type
3006 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3007                         asymbol *symbol ATTRIBUTE_UNUSED,
3008                         void *data ATTRIBUTE_UNUSED, asection *input_section,
3009                         bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
3010 {
3011   if (output_bfd != NULL)
3012     reloc_entry->address += input_section->output_offset;
3013
3014   return bfd_reloc_ok;
3015 }
3016 \f
3017
3018 /* Map BFD reloc types to NDS32 ELF reloc types.  */
3019
3020 struct nds32_reloc_map_entry
3021 {
3022   bfd_reloc_code_real_type bfd_reloc_val;
3023   unsigned char elf_reloc_val;
3024 };
3025
3026 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
3027 {
3028   {BFD_RELOC_NONE, R_NDS32_NONE},
3029   {BFD_RELOC_16, R_NDS32_16_RELA},
3030   {BFD_RELOC_32, R_NDS32_32_RELA},
3031   {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
3032   {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
3033
3034   {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
3035   {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
3036   {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
3037   {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
3038   {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
3039   {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
3040   {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
3041   {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
3042   {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
3043   {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
3044   {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
3045   {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
3046   {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
3047   {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
3048   {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
3049   {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
3050   {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
3051   {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
3052   {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
3053   {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
3054   {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
3055   {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
3056   {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
3057   {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
3058   {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
3059   {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
3060   {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
3061   {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
3062   {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
3063   {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
3064   {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
3065   {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
3066   {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
3067   {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
3068   {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
3069   {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
3070   {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
3071   {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
3072   {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
3073   {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
3074   {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
3075   {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
3076   {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
3077   {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
3078   {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
3079   {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
3080   {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
3081   {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
3082   {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
3083   {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
3084   {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
3085   {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
3086   {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
3087   {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
3088   {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
3089   {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
3090   {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
3091   {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
3092   {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
3093   {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
3094   {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
3095   {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
3096   {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
3097   {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
3098   {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
3099   {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
3100   {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
3101   {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
3102   {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
3103   {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
3104   {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
3105   {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
3106   {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
3107   {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
3108   {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
3109   {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
3110   {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
3111   {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
3112   {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
3113   {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
3114   {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
3115   {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
3116   {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
3117   {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
3118   {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
3119   {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
3120   {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
3121   {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
3122   {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
3123   {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
3124   {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
3125   {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
3126   {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
3127   {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
3128   {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
3129   {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
3130   {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
3131   {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
3132   {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
3133   {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
3134   {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
3135   {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
3136   /* Not sure.  */
3137   {BFD_RELOC_NDS32_TPOFF, R_NDS32_TLS_TPOFF},
3138   /* Missing: BFD_RELOC_NDS32_GOTTPOFF.  */
3139   {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
3140   {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
3141   {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
3142   {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
3143   {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
3144   {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
3145   {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
3146   {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
3147   {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
3148   {BFD_RELOC_NDS32_TLS_IE_LO12, R_NDS32_TLS_IE_LO12},
3149   {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
3150   {BFD_RELOC_NDS32_TLS_IEGP_HI20, R_NDS32_TLS_IEGP_HI20},
3151   {BFD_RELOC_NDS32_TLS_IEGP_LO12, R_NDS32_TLS_IEGP_LO12},
3152   {BFD_RELOC_NDS32_TLS_IEGP_LO12S2, R_NDS32_TLS_IEGP_LO12S2},
3153   {BFD_RELOC_NDS32_TLS_IEGP_LW, R_NDS32_TLS_IEGP_LW},
3154   {BFD_RELOC_NDS32_TLS_DESC, R_NDS32_TLS_DESC},
3155   {BFD_RELOC_NDS32_TLS_DESC_HI20, R_NDS32_TLS_DESC_HI20},
3156   {BFD_RELOC_NDS32_TLS_DESC_LO12, R_NDS32_TLS_DESC_LO12},
3157   {BFD_RELOC_NDS32_TLS_DESC_20, R_NDS32_TLS_DESC_20},
3158   {BFD_RELOC_NDS32_TLS_DESC_SDA17S2, R_NDS32_TLS_DESC_SDA17S2},
3159   {BFD_RELOC_NDS32_TLS_DESC_ADD, R_NDS32_TLS_DESC_ADD},
3160   {BFD_RELOC_NDS32_TLS_DESC_FUNC, R_NDS32_TLS_DESC_FUNC},
3161   {BFD_RELOC_NDS32_TLS_DESC_CALL, R_NDS32_TLS_DESC_CALL},
3162   {BFD_RELOC_NDS32_TLS_DESC_MEM, R_NDS32_TLS_DESC_MEM},
3163   {BFD_RELOC_NDS32_REMOVE, R_NDS32_RELAX_REMOVE},
3164   {BFD_RELOC_NDS32_GROUP, R_NDS32_RELAX_GROUP},
3165   {BFD_RELOC_NDS32_LSI, R_NDS32_LSI},
3166 };
3167
3168 /* Patch tag.  */
3169
3170 static reloc_howto_type *
3171 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3172                                  const char *r_name)
3173 {
3174   unsigned int i;
3175
3176   for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
3177     if (nds32_elf_howto_table[i].name != NULL
3178         && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
3179       return &nds32_elf_howto_table[i];
3180
3181   for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
3182     if (nds32_elf_relax_howto_table[i].name != NULL
3183         && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
3184       return &nds32_elf_relax_howto_table[i];
3185
3186   return NULL;
3187 }
3188
3189 static reloc_howto_type *
3190 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
3191 {
3192   if (code < R_NDS32_RELAX_ENTRY)
3193     {
3194       BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
3195       return &nds32_elf_howto_table[code];
3196     }
3197   else
3198     {
3199       if ((size_t) (code - R_NDS32_RELAX_ENTRY)
3200           >= ARRAY_SIZE (nds32_elf_relax_howto_table))
3201         {
3202           int i = code;
3203           i += 1;
3204         }
3205
3206       BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
3207                   < ARRAY_SIZE (nds32_elf_relax_howto_table));
3208       return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
3209     }
3210 }
3211
3212 static reloc_howto_type *
3213 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3214                                  bfd_reloc_code_real_type code)
3215 {
3216   unsigned int i;
3217
3218   for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
3219     {
3220       if (nds32_reloc_map[i].bfd_reloc_val == code)
3221         return bfd_elf32_bfd_reloc_type_table_lookup
3222           (nds32_reloc_map[i].elf_reloc_val);
3223     }
3224
3225   return NULL;
3226 }
3227
3228 /* Set the howto pointer for an NDS32 ELF reloc.  */
3229
3230 static bfd_boolean
3231 nds32_info_to_howto_rel (bfd *abfd, arelent *cache_ptr,
3232                          Elf_Internal_Rela *dst)
3233 {
3234   enum elf_nds32_reloc_type r_type;
3235
3236   r_type = ELF32_R_TYPE (dst->r_info);
3237   if (r_type > R_NDS32_GNU_VTENTRY)
3238     {
3239       /* xgettext:c-format */
3240       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3241                           abfd, r_type);
3242       bfd_set_error (bfd_error_bad_value);
3243       return FALSE;
3244     }
3245
3246   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
3247   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3248   return TRUE;
3249 }
3250
3251 static bfd_boolean
3252 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
3253                      Elf_Internal_Rela *dst)
3254 {
3255   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
3256
3257   if ((r_type == R_NDS32_NONE)
3258       || ((r_type > R_NDS32_GNU_VTENTRY)
3259           && (r_type < R_NDS32_max)))
3260     {
3261       cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3262       return TRUE;
3263     }
3264
3265   /* xgettext:c-format */
3266   _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type);
3267   bfd_set_error (bfd_error_bad_value);
3268   return FALSE;
3269 }
3270
3271 /* Support for core dump NOTE sections.
3272    Reference to include/linux/elfcore.h in Linux.  */
3273
3274 static bfd_boolean
3275 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3276 {
3277   int offset;
3278   size_t size;
3279
3280   switch (note->descsz)
3281     {
3282     case 0x114:
3283       /* Linux/NDS32 32-bit, ABI1.  */
3284
3285       /* pr_cursig */
3286       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3287
3288       /* pr_pid */
3289       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3290
3291       /* pr_reg */
3292       offset = 72;
3293       size = 200;
3294       break;
3295
3296     case 0xfc:
3297       /* Linux/NDS32 32-bit.  */
3298
3299       /* pr_cursig */
3300       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3301
3302       /* pr_pid */
3303       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3304
3305       /* pr_reg */
3306       offset = 72;
3307       size = 176;
3308       break;
3309
3310     default:
3311       return FALSE;
3312     }
3313
3314   /* Make a ".reg" section.  */
3315   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3316                                           size, note->descpos + offset);
3317 }
3318
3319 static bfd_boolean
3320 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3321 {
3322   switch (note->descsz)
3323     {
3324     case 124:
3325       /* Linux/NDS32.  */
3326
3327       /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform.  */
3328       elf_tdata (abfd)->core->program =
3329         _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3330       elf_tdata (abfd)->core->command =
3331         _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3332       break;
3333
3334     default:
3335       return FALSE;
3336     }
3337
3338   /* Note that for some reason, a spurious space is tacked
3339      onto the end of the args in some (at least one anyway)
3340      implementations, so strip it off if it exists.  */
3341   {
3342     char *command = elf_tdata (abfd)->core->command;
3343     int n = strlen (command);
3344
3345     if (0 < n && command[n - 1] == ' ')
3346       command[n - 1] = '\0';
3347   }
3348
3349   return TRUE;
3350 }
3351
3352 /* Hook called by the linker routine which adds symbols from an object
3353    file.  We must handle the special NDS32 section numbers here.
3354    We also keep watching for whether we need to create the sdata special
3355    linker sections.  */
3356
3357 static bfd_boolean
3358 nds32_elf_add_symbol_hook (bfd *abfd,
3359                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3360                            Elf_Internal_Sym *sym,
3361                            const char **namep ATTRIBUTE_UNUSED,
3362                            flagword *flagsp ATTRIBUTE_UNUSED,
3363                            asection **secp, bfd_vma *valp)
3364 {
3365   switch (sym->st_shndx)
3366     {
3367     case SHN_COMMON:
3368       /* Common symbols less than the GP size are automatically
3369          treated as SHN_MIPS_SCOMMON symbols.  */
3370       if (sym->st_size > elf_gp_size (abfd)
3371           || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3372         break;
3373
3374       /* st_value is the alignemnt constraint.
3375          That might be its actual size if it is an array or structure.  */
3376       switch (sym->st_value)
3377         {
3378         case 1:
3379           *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3380           break;
3381         case 2:
3382           *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3383           break;
3384         case 4:
3385           *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3386           break;
3387         case 8:
3388           *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3389           break;
3390         default:
3391           return TRUE;
3392         }
3393
3394       (*secp)->flags |= SEC_IS_COMMON;
3395       *valp = sym->st_size;
3396       break;
3397     }
3398
3399   return TRUE;
3400 }
3401
3402 /* This function can figure out the best location for a base register to access
3403    data relative to this base register
3404    INPUT:
3405    sda_d0: size of first DOUBLE WORD data section
3406    sda_w0: size of first WORD data section
3407    sda_h0: size of first HALF WORD data section
3408    sda_b : size of BYTE data section
3409    sda_hi: size of second HALF WORD data section
3410    sda_w1: size of second WORD data section
3411    sda_d1: size of second DOUBLE WORD data section
3412    OUTPUT:
3413    offset (always positive) from the beginning of sda_d0 if OK
3414    a negative error value if fail
3415    NOTE:
3416    these 7 sections have to be located back to back if exist
3417    a pass in 0 value for non-existing section   */
3418
3419 /* Due to the interpretation of simm15 field of load/store depending on
3420    data accessing size, the organization of base register relative data shall
3421    like the following figure
3422    -------------------------------------------
3423    |  DOUBLE WORD sized data (range +/- 128K)
3424    -------------------------------------------
3425    |  WORD sized data (range +/- 64K)
3426    -------------------------------------------
3427    |  HALF WORD sized data (range +/- 32K)
3428    -------------------------------------------
3429    |  BYTE sized data (range +/- 16K)
3430    -------------------------------------------
3431    |  HALF WORD sized data (range +/- 32K)
3432    -------------------------------------------
3433    |  WORD sized data (range +/- 64K)
3434    -------------------------------------------
3435    |  DOUBLE WORD sized data (range +/- 128K)
3436    -------------------------------------------
3437    Its base register shall be set to access these data freely.  */
3438
3439 /* We have to figure out the SDA_BASE value, so that we can adjust the
3440    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
3441    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
3442    target data.  We don't need to adjust the symbol value for an
3443    external symbol if we are producing relocatable output.  */
3444
3445 static asection *sda_rela_sec = NULL;
3446
3447 #define SDA_SECTION_NUM 10
3448
3449 static bfd_reloc_status_type
3450 nds32_elf_final_sda_base (bfd *                   output_bfd,
3451                           struct bfd_link_info *  info,
3452                           bfd_vma *               psb,
3453                           bfd_boolean             add_symbol)
3454 {
3455   int relax_fp_as_gp;
3456   struct elf_nds32_link_hash_table *table;
3457   struct bfd_link_hash_entry *h, *h2;
3458   long unsigned int total = 0;
3459   asection *first = NULL, *final = NULL, *temp;
3460   bfd_vma sda_base = 0;
3461
3462   h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3463   if (!h || (h->type != bfd_link_hash_defined
3464              && h->type != bfd_link_hash_defweak))
3465     {
3466       /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3467          4 byte-aligned.  Therefore, it has to set the first section ".data"
3468          4 byte-aligned.  */
3469       static const char sec_name[SDA_SECTION_NUM][10] =
3470         {
3471           ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3472           ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3473         };
3474       size_t i = 0;
3475
3476       if (output_bfd->sections == NULL)
3477         {
3478           *psb = elf_gp (output_bfd);
3479           return bfd_reloc_ok;
3480         }
3481
3482       /* Get the first and final section.  */
3483       while (i < ARRAY_SIZE (sec_name))
3484         {
3485           temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3486           if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3487             first = temp;
3488           if (temp && (temp->size != 0 || temp->rawsize != 0))
3489             final = temp;
3490
3491           /* Summarize the sections in order to check if joining .bss.  */
3492           if (temp && temp->size != 0)
3493             total += temp->size;
3494           else if (temp && temp->rawsize != 0)
3495             total += temp->rawsize;
3496
3497           i++;
3498         }
3499
3500       /* Check .bss size.  */
3501       temp = bfd_get_section_by_name (output_bfd, ".bss");
3502       if (temp)
3503         {
3504           if (temp->size != 0)
3505             total += temp->size;
3506           else if (temp->rawsize != 0)
3507             total += temp->rawsize;
3508
3509           if (total < 0x80000)
3510             {
3511               if (!first && (temp->size != 0 || temp->rawsize != 0))
3512                 first = temp;
3513               if ((temp->size != 0 || temp->rawsize != 0))
3514                 final = temp;
3515             }
3516         }
3517
3518       if (first && final)
3519         {
3520           /* The middle of data region.  */
3521           sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3522
3523           /* Find the section sda_base located.  */
3524           i = 0;
3525           while (i < ARRAY_SIZE (sec_name))
3526             {
3527               final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3528               if (final && (final->size != 0 || final->rawsize != 0)
3529                   && sda_base >= final->vma)
3530                 {
3531                   first = final;
3532                   i++;
3533                 }
3534               else
3535                 break;
3536             }
3537         }
3538       else
3539         {
3540           /* If there is not any default data section in output bfd, try to find
3541              the first data section.  If no data section be found, just simplily
3542              choose the first output section.  */
3543           temp = output_bfd->sections;
3544           while (temp)
3545             {
3546               if (temp->flags & SEC_ALLOC
3547                   && (((temp->flags & SEC_DATA)
3548                        && ((temp->flags & SEC_READONLY) == 0))
3549                       || (temp->flags & SEC_LOAD) == 0)
3550                   && (temp->size != 0 || temp->rawsize != 0))
3551                 {
3552                   if (!first)
3553                     first = temp;
3554                   final = temp;
3555                 }
3556               temp = temp->next;
3557             }
3558
3559           /* There is no data or bss section.  */
3560           if (!first || (first->size == 0 && first->rawsize == 0))
3561             {
3562               first = output_bfd->sections;
3563               while (first && first->size == 0 && first->rawsize == 0)
3564                 first = first->next;
3565             }
3566
3567           /* There is no concrete section.  */
3568           if (!first)
3569             {
3570               *psb = elf_gp (output_bfd);
3571               return bfd_reloc_ok;
3572             }
3573
3574           if (final && (final->vma + final->rawsize - first->vma) <= 0x4000)
3575             sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3576           else
3577             sda_base = first->vma + 0x2000;
3578         }
3579
3580       sda_base -= first->vma;
3581       sda_base = sda_base & (~7);
3582
3583       if (!_bfd_generic_link_add_one_symbol
3584           (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3585            (bfd_vma) sda_base, (const char *) NULL, FALSE,
3586            get_elf_backend_data (output_bfd)->collect, &h))
3587         return FALSE;
3588
3589       sda_rela_sec = first;
3590     }
3591
3592   /* Set _FP_BASE_ to _SDA_BASE_.  */
3593   table = nds32_elf_hash_table (info);
3594   relax_fp_as_gp = table->relax_fp_as_gp;
3595   h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME, FALSE, FALSE, FALSE);
3596   /* _SDA_BASE_ is difined in linker script.  */
3597   if (!first)
3598     {
3599       first = h->u.def.section;
3600       sda_base = h->u.def.value;
3601     }
3602
3603   if (relax_fp_as_gp && h2
3604       && (h2->type == bfd_link_hash_undefweak
3605           || h2->type == bfd_link_hash_undefined))
3606     {
3607       /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3608          And set FP equal to SDA_BASE to do relaxation for
3609          la $fp, _FP_BASE_.  */
3610       if (!_bfd_generic_link_add_one_symbol
3611           (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3612            first, sda_base, (const char *) NULL,
3613            FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3614         return FALSE;
3615     }
3616
3617   if (add_symbol)
3618     {
3619       if (h)
3620         {
3621           /* Now set gp.  */
3622           elf_gp (output_bfd) = (h->u.def.value
3623                                  + h->u.def.section->output_section->vma
3624                                  + h->u.def.section->output_offset);
3625         }
3626       else
3627         {
3628           _bfd_error_handler (_("error: can't find symbol: %s"), "_SDA_BASE_");
3629           return bfd_reloc_dangerous;
3630         }
3631     }
3632
3633   *psb = h->u.def.value
3634     + h->u.def.section->output_section->vma
3635     + h->u.def.section->output_offset;
3636   return bfd_reloc_ok;
3637 }
3638 \f
3639
3640 /* Return size of a PLT entry.  */
3641 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3642
3643 /* Create an entry in an nds32 ELF linker hash table.  */
3644
3645 static struct bfd_hash_entry *
3646 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3647                              struct bfd_hash_table *table,
3648                              const char *string)
3649 {
3650   struct elf_nds32_link_hash_entry *ret;
3651
3652   ret = (struct elf_nds32_link_hash_entry *) entry;
3653
3654   /* Allocate the structure if it has not already been allocated by a
3655      subclass.  */
3656   if (ret == NULL)
3657     ret = (struct elf_nds32_link_hash_entry *)
3658        bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3659
3660   if (ret == NULL)
3661     return (struct bfd_hash_entry *) ret;
3662
3663   /* Call the allocation method of the superclass.  */
3664   ret = (struct elf_nds32_link_hash_entry *)
3665     _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3666
3667   if (ret != NULL)
3668     {
3669       struct elf_nds32_link_hash_entry *eh;
3670
3671       eh = (struct elf_nds32_link_hash_entry *) ret;
3672       eh->dyn_relocs = NULL;
3673       eh->tls_type = GOT_UNKNOWN;
3674       eh->offset_to_gp = 0;
3675     }
3676
3677   return (struct bfd_hash_entry *) ret;
3678 }
3679
3680 /* Create an nds32 ELF linker hash table.  */
3681
3682 static struct bfd_link_hash_table *
3683 nds32_elf_link_hash_table_create (bfd *abfd)
3684 {
3685   struct elf_nds32_link_hash_table *ret;
3686
3687   size_t amt = sizeof (struct elf_nds32_link_hash_table);
3688
3689   ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3690   if (ret == NULL)
3691     return NULL;
3692
3693   /* Patch tag.  */
3694   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3695                                       nds32_elf_link_hash_newfunc,
3696                                       sizeof (struct elf_nds32_link_hash_entry),
3697                                       NDS32_ELF_DATA))
3698     {
3699       free (ret);
3700       return NULL;
3701     }
3702
3703   ret->sdynbss = NULL;
3704   ret->srelbss = NULL;
3705   ret->sym_ld_script = NULL;
3706
3707   return &ret->root.root;
3708 }
3709
3710 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3711    shortcuts to them in our hash table.  */
3712
3713 static bfd_boolean
3714 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3715 {
3716   struct elf_link_hash_table *ehtab;
3717
3718   if (!_bfd_elf_create_got_section (dynobj, info))
3719     return FALSE;
3720
3721   ehtab = elf_hash_table (info);
3722   ehtab->sgot = bfd_get_section_by_name (dynobj, ".got");
3723   ehtab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3724   if (!ehtab->sgot || !ehtab->sgotplt)
3725     abort ();
3726
3727   /* _bfd_elf_create_got_section will create it for us.  */
3728   ehtab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3729   if (ehtab->srelgot == NULL
3730       || !bfd_set_section_flags (ehtab->srelgot,
3731                                  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3732                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED
3733                                   | SEC_READONLY))
3734       || !bfd_set_section_alignment (ehtab->srelgot, 2))
3735     return FALSE;
3736
3737   return TRUE;
3738 }
3739
3740 /* Create dynamic sections when linking against a dynamic object.  */
3741
3742 static bfd_boolean
3743 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3744 {
3745   struct elf_link_hash_table *ehtab;
3746   struct elf_nds32_link_hash_table *htab;
3747   flagword flags, pltflags;
3748   register asection *s;
3749   const struct elf_backend_data *bed;
3750   int ptralign = 2;             /* 32-bit  */
3751   const char *secname;
3752   char *relname;
3753   flagword secflags;
3754   asection *sec;
3755
3756   bed = get_elf_backend_data (abfd);
3757   ehtab = elf_hash_table (info);
3758   htab = nds32_elf_hash_table (info);
3759
3760   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3761      .rel[a].bss sections.  */
3762
3763   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3764            | SEC_LINKER_CREATED);
3765
3766   pltflags = flags;
3767   pltflags |= SEC_CODE;
3768   if (bed->plt_not_loaded)
3769     pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3770   if (bed->plt_readonly)
3771     pltflags |= SEC_READONLY;
3772
3773   s = bfd_make_section (abfd, ".plt");
3774   ehtab->splt = s;
3775   if (s == NULL
3776       || !bfd_set_section_flags (s, pltflags)
3777       || !bfd_set_section_alignment (s, bed->plt_alignment))
3778     return FALSE;
3779
3780   if (bed->want_plt_sym)
3781     {
3782       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3783          .plt section.  */
3784       struct bfd_link_hash_entry *bh = NULL;
3785       struct elf_link_hash_entry *h;
3786
3787       if (!(_bfd_generic_link_add_one_symbol
3788             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3789              (bfd_vma) 0, (const char *) NULL, FALSE,
3790              get_elf_backend_data (abfd)->collect, &bh)))
3791         return FALSE;
3792
3793       h = (struct elf_link_hash_entry *) bh;
3794       h->def_regular = 1;
3795       h->type = STT_OBJECT;
3796
3797       if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3798         return FALSE;
3799     }
3800
3801   s = bfd_make_section (abfd,
3802                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3803   ehtab->srelplt = s;
3804   if (s == NULL
3805       || !bfd_set_section_flags (s, flags | SEC_READONLY)
3806       || !bfd_set_section_alignment (s, ptralign))
3807     return FALSE;
3808
3809   if (ehtab->sgot == NULL && !create_got_section (abfd, info))
3810     return FALSE;
3811
3812   for (sec = abfd->sections; sec; sec = sec->next)
3813     {
3814       secflags = bfd_section_flags (sec);
3815       if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3816           || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3817         continue;
3818       secname = bfd_section_name (sec);
3819       relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3820       strcpy (relname, ".rela");
3821       strcat (relname, secname);
3822       if (bfd_get_section_by_name (abfd, secname))
3823         continue;
3824       s = bfd_make_section (abfd, relname);
3825       if (s == NULL
3826           || !bfd_set_section_flags (s, flags | SEC_READONLY)
3827           || !bfd_set_section_alignment (s, ptralign))
3828         return FALSE;
3829     }
3830
3831   if (bed->want_dynbss)
3832     {
3833       /* The .dynbss section is a place to put symbols which are defined
3834          by dynamic objects, are referenced by regular objects, and are
3835          not functions.  We must allocate space for them in the process
3836          image and use a R_*_COPY reloc to tell the dynamic linker to
3837          initialize them at run time.  The linker script puts the .dynbss
3838          section into the .bss section of the final image.  */
3839       s = bfd_make_section (abfd, ".dynbss");
3840       htab->sdynbss = s;
3841       if (s == NULL
3842           || !bfd_set_section_flags (s, SEC_ALLOC | SEC_LINKER_CREATED))
3843         return FALSE;
3844       /* The .rel[a].bss section holds copy relocs.  This section is not
3845          normally needed.  We need to create it here, though, so that the
3846          linker will map it to an output section.  We can't just create it
3847          only if we need it, because we will not know whether we need it
3848          until we have seen all the input files, and the first time the
3849          main linker code calls BFD after examining all the input files
3850          (size_dynamic_sections) the input sections have already been
3851          mapped to the output sections.  If the section turns out not to
3852          be needed, we can discard it later.  We will never need this
3853          section when generating a shared object, since they do not use
3854          copy relocs.  */
3855       if (!bfd_link_pic (info))
3856         {
3857           s = bfd_make_section (abfd, (bed->default_use_rela_p
3858                                        ? ".rela.bss" : ".rel.bss"));
3859           htab->srelbss = s;
3860           if (s == NULL
3861               || !bfd_set_section_flags (s, flags | SEC_READONLY)
3862               || !bfd_set_section_alignment (s, ptralign))
3863             return FALSE;
3864         }
3865     }
3866
3867   return TRUE;
3868 }
3869
3870 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3871 static void
3872 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3873                                 struct elf_link_hash_entry *dir,
3874                                 struct elf_link_hash_entry *ind)
3875 {
3876   struct elf_nds32_link_hash_entry *edir, *eind;
3877
3878   edir = (struct elf_nds32_link_hash_entry *) dir;
3879   eind = (struct elf_nds32_link_hash_entry *) ind;
3880
3881   if (eind->dyn_relocs != NULL)
3882     {
3883       if (edir->dyn_relocs != NULL)
3884         {
3885           struct elf_dyn_relocs **pp;
3886           struct elf_dyn_relocs *p;
3887
3888           if (ind->root.type == bfd_link_hash_indirect)
3889             abort ();
3890
3891           /* Add reloc counts against the weak sym to the strong sym
3892              list.  Merge any entries against the same section.  */
3893           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3894             {
3895               struct elf_dyn_relocs *q;
3896
3897               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3898                 if (q->sec == p->sec)
3899                   {
3900                     q->pc_count += p->pc_count;
3901                     q->count += p->count;
3902                     *pp = p->next;
3903                     break;
3904                   }
3905               if (q == NULL)
3906                 pp = &p->next;
3907             }
3908           *pp = edir->dyn_relocs;
3909         }
3910
3911       edir->dyn_relocs = eind->dyn_relocs;
3912       eind->dyn_relocs = NULL;
3913     }
3914
3915   if (ind->root.type == bfd_link_hash_indirect)
3916     {
3917       if (dir->got.refcount <= 0)
3918         {
3919           edir->tls_type = eind->tls_type;
3920           eind->tls_type = GOT_UNKNOWN;
3921         }
3922     }
3923
3924   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3925 }
3926 \f
3927
3928 /* Find dynamic relocs for H that apply to read-only sections.  */
3929
3930 static asection *
3931 readonly_dynrelocs (struct elf_link_hash_entry *h)
3932 {
3933   struct elf_dyn_relocs *p;
3934
3935   for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3936     {
3937       asection *s = p->sec->output_section;
3938
3939       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3940         return p->sec;
3941     }
3942   return NULL;
3943 }
3944
3945 /* Adjust a symbol defined by a dynamic object and referenced by a
3946    regular object.  The current definition is in some section of the
3947    dynamic object, but we're not including those sections.  We have to
3948    change the definition to something the rest of the link can
3949    understand.  */
3950
3951 static bfd_boolean
3952 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3953                                  struct elf_link_hash_entry *h)
3954 {
3955   struct elf_nds32_link_hash_table *htab;
3956   bfd *dynobj;
3957   asection *s;
3958   unsigned int power_of_two;
3959
3960   dynobj = elf_hash_table (info)->dynobj;
3961
3962   /* Make sure we know what is going on here.  */
3963   BFD_ASSERT (dynobj != NULL
3964               && (h->needs_plt
3965                   || h->is_weakalias
3966                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3967
3968
3969   /* If this is a function, put it in the procedure linkage table.  We
3970      will fill in the contents of the procedure linkage table later,
3971      when we know the address of the .got section.  */
3972   if (h->type == STT_FUNC || h->needs_plt)
3973     {
3974       if (!bfd_link_pic (info)
3975           && !h->def_dynamic
3976           && !h->ref_dynamic
3977           && h->root.type != bfd_link_hash_undefweak
3978           && h->root.type != bfd_link_hash_undefined)
3979         {
3980           /* This case can occur if we saw a PLT reloc in an input
3981              file, but the symbol was never referred to by a dynamic
3982              object.  In such a case, we don't actually need to build
3983              a procedure linkage table, and we can just do a PCREL
3984              reloc instead.  */
3985           h->plt.offset = (bfd_vma) - 1;
3986           h->needs_plt = 0;
3987         }
3988
3989       return TRUE;
3990     }
3991   else
3992     h->plt.offset = (bfd_vma) - 1;
3993
3994   /* If this is a weak symbol, and there is a real definition, the
3995      processor independent code will have arranged for us to see the
3996      real definition first, and we can just use the same value.  */
3997   if (h->is_weakalias)
3998     {
3999       struct elf_link_hash_entry *def = weakdef (h);
4000       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
4001       h->root.u.def.section = def->root.u.def.section;
4002       h->root.u.def.value = def->root.u.def.value;
4003       return TRUE;
4004     }
4005
4006   /* This is a reference to a symbol defined by a dynamic object which
4007      is not a function.  */
4008
4009   /* If we are creating a shared library, we must presume that the
4010      only references to the symbol are via the global offset table.
4011      For such cases we need not do anything here; the relocations will
4012      be handled correctly by relocate_section.  */
4013   if (bfd_link_pic (info))
4014     return TRUE;
4015
4016   /* If there are no references to this symbol that do not use the
4017      GOT, we don't need to generate a copy reloc.  */
4018   if (!h->non_got_ref)
4019     return TRUE;
4020
4021   /* If -z nocopyreloc was given, we won't generate them either.  */
4022   if (0 && info->nocopyreloc)
4023     {
4024       h->non_got_ref = 0;
4025       return TRUE;
4026     }
4027
4028   /* If we don't find any dynamic relocs in read-only sections, then
4029      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
4030   if (!readonly_dynrelocs (h))
4031     {
4032       h->non_got_ref = 0;
4033       return TRUE;
4034     }
4035
4036   /* We must allocate the symbol in our .dynbss section, which will
4037      become part of the .bss section of the executable.  There will be
4038      an entry for this symbol in the .dynsym section.  The dynamic
4039      object will contain position independent code, so all references
4040      from the dynamic object to this symbol will go through the global
4041      offset table.  The dynamic linker will use the .dynsym entry to
4042      determine the address it must put in the global offset table, so
4043      both the dynamic object and the regular object will refer to the
4044      same memory location for the variable.  */
4045
4046   htab = nds32_elf_hash_table (info);
4047   s = htab->sdynbss;
4048   BFD_ASSERT (s != NULL);
4049
4050   /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
4051      to copy the initial value out of the dynamic object and into the
4052      runtime process image.  We need to remember the offset into the
4053      .rela.bss section we are going to use.  */
4054   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4055     {
4056       asection *srel;
4057
4058       srel = htab->srelbss;
4059       BFD_ASSERT (srel != NULL);
4060       srel->size += sizeof (Elf32_External_Rela);
4061       h->needs_copy = 1;
4062     }
4063
4064   /* We need to figure out the alignment required for this symbol.  I
4065      have no idea how ELF linkers handle this.  */
4066   power_of_two = bfd_log2 (h->size);
4067   if (power_of_two > 3)
4068     power_of_two = 3;
4069
4070   /* Apply the required alignment.  */
4071   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4072   if (power_of_two > bfd_section_alignment (s))
4073     {
4074       if (!bfd_set_section_alignment (s, power_of_two))
4075         return FALSE;
4076     }
4077
4078   /* Define the symbol as being at this point in the section.  */
4079   h->root.u.def.section = s;
4080   h->root.u.def.value = s->size;
4081
4082   /* Increment the section size to make room for the symbol.  */
4083   s->size += h->size;
4084
4085   return TRUE;
4086 }
4087
4088 /* Allocate space in .plt, .got and associated reloc sections for
4089    dynamic relocs.  */
4090
4091 static bfd_boolean
4092 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
4093 {
4094   struct bfd_link_info *info;
4095   struct elf_link_hash_table *ehtab;
4096   struct elf_nds32_link_hash_table *htab;
4097   struct elf_nds32_link_hash_entry *eh;
4098   struct elf_dyn_relocs *p;
4099
4100   if (h->root.type == bfd_link_hash_indirect)
4101     return TRUE;
4102
4103   /* When warning symbols are created, they **replace** the "real"
4104      entry in the hash table, thus we never get to see the real
4105      symbol in a hash traversal. So look at it now.  */
4106   if (h->root.type == bfd_link_hash_warning)
4107     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4108
4109   eh = (struct elf_nds32_link_hash_entry *) h;
4110
4111   info = (struct bfd_link_info *) inf;
4112   ehtab = elf_hash_table (info);
4113   htab = nds32_elf_hash_table (info);
4114   if (htab == NULL)
4115     return FALSE;
4116
4117   eh = (struct elf_nds32_link_hash_entry *) h;
4118
4119   if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
4120       && h->plt.refcount > 0
4121       && !(bfd_link_pie (info) && h->def_regular))
4122     {
4123       /* Make sure this symbol is output as a dynamic symbol.
4124          Undefined weak syms won't yet be marked as dynamic.  */
4125       if (h->dynindx == -1 && !h->forced_local)
4126         {
4127           if (!bfd_elf_link_record_dynamic_symbol (info, h))
4128             return FALSE;
4129         }
4130
4131       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
4132         {
4133           asection *s = ehtab->splt;
4134
4135           /* If this is the first .plt entry, make room for the special
4136              first entry.  */
4137           if (s->size == 0)
4138             s->size += PLT_ENTRY_SIZE;
4139
4140           h->plt.offset = s->size;
4141
4142           /* If this symbol is not defined in a regular file, and we are
4143              not generating a shared library, then set the symbol to this
4144              location in the .plt.  This is required to make function
4145              pointers compare as equal between the normal executable and
4146              the shared library.  */
4147           if (!bfd_link_pic (info) && !h->def_regular)
4148             {
4149               h->root.u.def.section = s;
4150               h->root.u.def.value = h->plt.offset;
4151             }
4152
4153           /* Make room for this entry.  */
4154           s->size += PLT_ENTRY_SIZE;
4155
4156           /* We also need to make an entry in the .got.plt section, which
4157              will be placed in the .got section by the linker script.  */
4158           ehtab->sgotplt->size += 4;
4159
4160           /* We also need to make an entry in the .rel.plt section.  */
4161           ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4162           if (htab->tls_desc_trampoline)
4163             htab->next_tls_desc_index++;
4164         }
4165       else
4166         {
4167           h->plt.offset = (bfd_vma) - 1;
4168           h->needs_plt = 0;
4169         }
4170     }
4171   else
4172     {
4173       h->plt.offset = (bfd_vma) - 1;
4174       h->needs_plt = 0;
4175     }
4176
4177   if (h->got.refcount > 0)
4178     {
4179       asection *sgot;
4180       bfd_boolean dyn;
4181       int tls_type = elf32_nds32_hash_entry (h)->tls_type;
4182
4183       /* Make sure this symbol is output as a dynamic symbol.
4184          Undefined weak syms won't yet be marked as dynamic.  */
4185       if (h->dynindx == -1 && !h->forced_local)
4186         {
4187           if (!bfd_elf_link_record_dynamic_symbol (info, h))
4188             return FALSE;
4189         }
4190
4191       sgot = elf_hash_table (info)->sgot;
4192       h->got.offset = sgot->size;
4193
4194       if (tls_type == GOT_UNKNOWN)
4195         abort ();
4196
4197       /* Non-TLS symbols, and TLS_IE need one GOT slot.  */
4198       if (tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4199         sgot->size += 4;
4200       else
4201         {
4202           /* TLS_DESC, TLS_GD, and TLS_LD need 2 consecutive GOT slots.  */
4203           if (tls_type & GOT_TLS_DESC)
4204             sgot->size += 8;
4205         }
4206
4207       dyn = htab->root.dynamic_sections_created;
4208
4209       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
4210         {
4211           if (tls_type == GOT_TLS_DESC && htab->tls_desc_trampoline)
4212             {
4213               /* TLS_DESC with trampoline needs a relocation slot
4214                  within .rela.plt.  */
4215               htab->num_tls_desc++;
4216               ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4217               htab->tls_trampoline = -1;
4218             }
4219           else
4220             {
4221               /* other relocations, including TLS_DESC without trampoline, need
4222                  a relocation slot within .rela.got.  */
4223               ehtab->srelgot->size += sizeof (Elf32_External_Rela);
4224             }
4225         }
4226     }
4227   else
4228     h->got.offset = (bfd_vma)-1;
4229
4230   if (eh->dyn_relocs == NULL)
4231     return TRUE;
4232
4233   /* In the shared -Bsymbolic case, discard space allocated for
4234      dynamic pc-relative relocs against symbols which turn out to be
4235      defined in regular objects.  For the normal shared case, discard
4236      space for pc-relative relocs that have become local due to symbol
4237      visibility changes.  */
4238
4239   if (bfd_link_pic (info))
4240     {
4241       if (h->def_regular && (h->forced_local || info->symbolic))
4242         {
4243           struct elf_dyn_relocs **pp;
4244
4245           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
4246             {
4247               p->count -= p->pc_count;
4248               p->pc_count = 0;
4249               if (p->count == 0)
4250                 *pp = p->next;
4251               else
4252                 pp = &p->next;
4253             }
4254         }
4255     }
4256   else
4257     {
4258       /* For the non-shared case, discard space for relocs against
4259          symbols which turn out to need copy relocs or are not dynamic.  */
4260
4261       if (!h->non_got_ref
4262           && ((h->def_dynamic
4263                && !h->def_regular)
4264               || (htab->root.dynamic_sections_created
4265                   && (h->root.type == bfd_link_hash_undefweak
4266                       || h->root.type == bfd_link_hash_undefined))))
4267         {
4268           /* Make sure this symbol is output as a dynamic symbol.
4269              Undefined weak syms won't yet be marked as dynamic.  */
4270           if (h->dynindx == -1 && !h->forced_local)
4271             {
4272               if (!bfd_elf_link_record_dynamic_symbol (info, h))
4273                 return FALSE;
4274             }
4275
4276           /* If that succeeded, we know we'll be keeping all the
4277              relocs.  */
4278           if (h->dynindx != -1)
4279             goto keep;
4280         }
4281
4282       eh->dyn_relocs = NULL;
4283
4284     keep:;
4285     }
4286
4287   /* Finally, allocate space.  */
4288   for (p = eh->dyn_relocs; p != NULL; p = p->next)
4289     {
4290       asection *sreloc = elf_section_data (p->sec)->sreloc;
4291       sreloc->size += p->count * sizeof (Elf32_External_Rela);
4292     }
4293
4294   return TRUE;
4295 }
4296
4297 /* Add relocation REL to the end of relocation section SRELOC.  */
4298
4299 static void
4300 elf32_nds32_add_dynreloc (bfd *output_bfd,
4301                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
4302                           asection *sreloc, Elf_Internal_Rela *rel)
4303 {
4304   bfd_byte *loc;
4305   if (sreloc == NULL)
4306     abort ();
4307
4308   loc = sreloc->contents;
4309   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4310   if (sreloc->reloc_count * sizeof (Elf32_External_Rela) > sreloc->size)
4311     abort ();
4312
4313   bfd_elf32_swap_reloca_out (output_bfd, rel, loc);
4314 }
4315
4316 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
4317    read-only sections.  */
4318
4319 static bfd_boolean
4320 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
4321 {
4322   asection *sec;
4323
4324   if (h->root.type == bfd_link_hash_indirect)
4325     return TRUE;
4326
4327   sec = readonly_dynrelocs (h);
4328   if (sec != NULL)
4329     {
4330       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
4331
4332       info->flags |= DF_TEXTREL;
4333       info->callbacks->minfo
4334         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
4335          sec->owner, h->root.root.string, sec);
4336
4337       /* Not an error, just cut short the traversal.  */
4338       return FALSE;
4339     }
4340   return TRUE;
4341 }
4342
4343 /* Set the sizes of the dynamic sections.  */
4344
4345 static bfd_boolean
4346 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
4347                                  struct bfd_link_info *info)
4348 {
4349   struct elf_nds32_link_hash_table *htab;
4350   bfd *dynobj;
4351   asection *s;
4352   bfd_boolean relocs;
4353   bfd_boolean plt;
4354   bfd *ibfd;
4355
4356   htab = nds32_elf_hash_table (info);
4357   if (htab == NULL)
4358     return FALSE;
4359
4360   dynobj = elf_hash_table (info)->dynobj;
4361   BFD_ASSERT (dynobj != NULL);
4362
4363   if (elf_hash_table (info)->dynamic_sections_created)
4364     {
4365       /* Set the contents of the .interp section to the interpreter.  */
4366       if (bfd_link_executable (info) && !info->nointerp)
4367         {
4368           s = bfd_get_section_by_name (dynobj, ".interp");
4369           BFD_ASSERT (s != NULL);
4370           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4371           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4372         }
4373     }
4374
4375   /* Set up .got offsets for local syms, and space for local dynamic
4376      relocs.  */
4377   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4378     {
4379       bfd_signed_vma *local_got;
4380       bfd_signed_vma *end_local_got;
4381       bfd_size_type locsymcount;
4382       Elf_Internal_Shdr *symtab_hdr;
4383       asection *sgot;
4384       char *local_tls_type;
4385       unsigned long symndx;
4386       bfd_vma *local_tlsdesc_gotent;
4387
4388       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4389         continue;
4390
4391       for (s = ibfd->sections; s != NULL; s = s->next)
4392         {
4393           struct elf_dyn_relocs *p;
4394
4395           for (p = ((struct elf_dyn_relocs *)
4396                     elf_section_data (s)->local_dynrel);
4397                p != NULL; p = p->next)
4398             {
4399               if (!bfd_is_abs_section (p->sec)
4400                   && bfd_is_abs_section (p->sec->output_section))
4401                 {
4402                   /* Input section has been discarded, either because
4403                      it is a copy of a linkonce section or due to
4404                      linker script /DISCARD/, so we'll be discarding
4405                      the relocs too.  */
4406                 }
4407               else if (p->count != 0)
4408                 {
4409                   asection *sreloc = elf_section_data (p->sec)->sreloc;
4410                   sreloc->size += p->count * sizeof (Elf32_External_Rela);
4411                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4412                     info->flags |= DF_TEXTREL;
4413                 }
4414             }
4415         }
4416
4417       local_got = elf_local_got_refcounts (ibfd);
4418       if (!local_got)
4419         continue;
4420
4421       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4422       locsymcount = symtab_hdr->sh_info;
4423       end_local_got = local_got + locsymcount;
4424       sgot = elf_hash_table (info)->sgot;
4425       local_tls_type = elf32_nds32_local_got_tls_type (ibfd);
4426       local_tlsdesc_gotent = elf32_nds32_local_tlsdesc_gotent (ibfd);
4427       for (symndx = 0; local_got < end_local_got;
4428            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent, ++symndx)
4429         {
4430           if (*local_got > 0)
4431             {
4432               int num_of_got_entry_needed = 0;
4433               *local_got = sgot->size;
4434               *local_tlsdesc_gotent = sgot->size;
4435
4436               /* TLS_NORMAL, and TLS_IE need one slot in .got.  */
4437               if (*local_tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4438                 num_of_got_entry_needed = 1;
4439               /* TLS_GD, TLS_LD, and TLS_DESC need an 8-byte structure in the GOT.  */
4440               else if (*local_tls_type & GOT_TLS_DESC)
4441                 num_of_got_entry_needed = 2;
4442
4443               sgot->size += (num_of_got_entry_needed << 2);
4444
4445               /* non-relax-able TLS_DESCs need a slot in .rela.plt.
4446                  others need a slot in .rela.got.  */
4447               if (*local_tls_type == GOT_TLS_DESC)
4448                 {
4449                   if (bfd_link_pic (info))
4450                     {
4451                       if (htab->tls_desc_trampoline)
4452                         {
4453                           htab->num_tls_desc++;
4454                           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
4455                           htab->tls_trampoline = -1;
4456                         }
4457                       else
4458                         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4459                     }
4460                   else
4461                     {
4462                       /* TLS_DESC -> TLS_LE  */
4463                     }
4464                 }
4465               else
4466                 {
4467                   htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4468                 }
4469             }
4470           else
4471             {
4472               *local_got = (bfd_vma) -1;
4473               *local_tlsdesc_gotent = (bfd_vma) -1;
4474             }
4475         }
4476     }
4477
4478   /* Allocate global sym .plt and .got entries, and space for global
4479      sym dynamic relocs.  */
4480   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4481
4482   /* For every jump slot reserved in the sgotplt, reloc_count is
4483      incremented.  However, when we reserve space for TLS descriptors,
4484      it's not incremented, so in order to compute the space reserved
4485      for them, it suffices to multiply the reloc count by the jump
4486      slot size.  */
4487   if (htab->tls_desc_trampoline && htab->root.srelplt)
4488     htab->sgotplt_jump_table_size = elf32_nds32_compute_jump_table_size (htab);
4489
4490   if (htab->tls_trampoline)
4491     {
4492       htab->tls_trampoline = htab->root.splt->size;
4493
4494       /* If we're not using lazy TLS relocations, don't generate the
4495          PLT and GOT entries they require.  */
4496       if (!(info->flags & DF_BIND_NOW))
4497         {
4498           htab->dt_tlsdesc_got = htab->root.sgot->size;
4499           htab->root.sgot->size += 4;
4500
4501           htab->dt_tlsdesc_plt = htab->root.splt->size;
4502           htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
4503         }
4504     }
4505
4506   /* We now have determined the sizes of the various dynamic sections.
4507      Allocate memory for them.  */
4508   /* The check_relocs and adjust_dynamic_symbol entry points have
4509      determined the sizes of the various dynamic sections.  Allocate
4510      memory for them.  */
4511   plt = FALSE;
4512   relocs = FALSE;
4513   for (s = dynobj->sections; s != NULL; s = s->next)
4514     {
4515       if ((s->flags & SEC_LINKER_CREATED) == 0)
4516         continue;
4517
4518       if (s == htab->root.splt)
4519         {
4520           /* Strip this section if we don't need it; see the
4521              comment below.  */
4522           plt = s->size != 0;
4523         }
4524       else if (s == elf_hash_table (info)->sgot)
4525         {
4526           got_size += s->size;
4527         }
4528       else if (s == elf_hash_table (info)->sgotplt)
4529         {
4530           got_size += s->size;
4531         }
4532       else if (strncmp (bfd_section_name (s), ".rela", 5) == 0)
4533         {
4534           if (s->size != 0 && s != elf_hash_table (info)->srelplt)
4535             relocs = TRUE;
4536
4537           /* We use the reloc_count field as a counter if we need
4538              to copy relocs into the output file.  */
4539           s->reloc_count = 0;
4540         }
4541       else
4542         {
4543           /* It's not one of our sections, so don't allocate space.  */
4544           continue;
4545         }
4546
4547       if (s->size == 0)
4548         {
4549           /* If we don't need this section, strip it from the
4550              output file.  This is mostly to handle .rela.bss and
4551              .rela.plt.  We must create both sections in
4552              create_dynamic_sections, because they must be created
4553              before the linker maps input sections to output
4554              sections.  The linker does that before
4555              adjust_dynamic_symbol is called, and it is that
4556              function which decides whether anything needs to go
4557              into these sections.  */
4558           s->flags |= SEC_EXCLUDE;
4559           continue;
4560         }
4561
4562       /* Allocate memory for the section contents.  We use bfd_zalloc
4563          here in case unused entries are not reclaimed before the
4564          section's contents are written out.  This should not happen,
4565          but this way if it does, we get a R_NDS32_NONE reloc instead
4566          of garbage.  */
4567       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4568       if (s->contents == NULL)
4569         return FALSE;
4570     }
4571
4572
4573   if (htab->root.dynamic_sections_created)
4574     {
4575       /* Add some entries to the .dynamic section.  We fill in the
4576          values later, in nds32_elf_finish_dynamic_sections, but we
4577          must add the entries now so that we get the correct size for
4578          the .dynamic section.  The DT_DEBUG entry is filled in by the
4579          dynamic linker and used by the debugger.  */
4580 #define add_dynamic_entry(TAG, VAL) \
4581   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4582
4583       if (bfd_link_executable (info))
4584         {
4585           if (!add_dynamic_entry (DT_DEBUG, 0))
4586             return FALSE;
4587         }
4588
4589       if (elf_hash_table (info)->splt->size != 0)
4590         {
4591           if (!add_dynamic_entry (DT_PLTGOT, 0)
4592               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4593               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4594               || !add_dynamic_entry (DT_JMPREL, 0))
4595             return FALSE;
4596         }
4597
4598       if (htab->tls_desc_trampoline && plt)
4599         {
4600           if (htab->dt_tlsdesc_plt
4601               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4602                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4603             return FALSE;
4604         }
4605
4606       if (relocs)
4607         {
4608           if (!add_dynamic_entry (DT_RELA, 0)
4609               || !add_dynamic_entry (DT_RELASZ, 0)
4610               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4611             return FALSE;
4612
4613           /* If any dynamic relocs apply to a read-only section,
4614              then we need a DT_TEXTREL entry.  */
4615           if ((info->flags & DF_TEXTREL) == 0)
4616             elf_link_hash_traverse (&htab->root, maybe_set_textrel,
4617                                     (void *) info);
4618
4619           if ((info->flags & DF_TEXTREL) != 0)
4620             {
4621               if (!add_dynamic_entry (DT_TEXTREL, 0))
4622                 return FALSE;
4623             }
4624         }
4625     }
4626 #undef add_dynamic_entry
4627
4628   return TRUE;
4629 }
4630
4631 static bfd_reloc_status_type
4632 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4633                          bfd_vma relocation, bfd_byte *location)
4634 {
4635   int size;
4636   bfd_vma x = 0;
4637   bfd_reloc_status_type flag;
4638   unsigned int rightshift = howto->rightshift;
4639   unsigned int bitpos = howto->bitpos;
4640
4641   /* If the size is negative, negate RELOCATION.  This isn't very
4642      general.  */
4643   if (howto->size < 0)
4644     relocation = -relocation;
4645
4646   /* Get the value we are going to relocate.  */
4647   size = bfd_get_reloc_size (howto);
4648   switch (size)
4649     {
4650     default:
4651       abort ();
4652       break;
4653     case 0:
4654       return bfd_reloc_ok;
4655     case 2:
4656       x = bfd_getb16 (location);
4657       break;
4658     case 4:
4659       x = bfd_getb32 (location);
4660       break;
4661     }
4662
4663   /* Check for overflow.  FIXME: We may drop bits during the addition
4664      which we don't check for.  We must either check at every single
4665      operation, which would be tedious, or we must do the computations
4666      in a type larger than bfd_vma, which would be inefficient.  */
4667   flag = bfd_reloc_ok;
4668   if (howto->complain_on_overflow != complain_overflow_dont)
4669     {
4670       bfd_vma addrmask, fieldmask, signmask, ss;
4671       bfd_vma a, b, sum;
4672
4673       /* Get the values to be added together.  For signed and unsigned
4674          relocations, we assume that all values should be truncated to
4675          the size of an address.  For bitfields, all the bits matter.
4676          See also bfd_check_overflow.  */
4677       fieldmask = N_ONES (howto->bitsize);
4678       signmask = ~fieldmask;
4679       addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4680       a = (relocation & addrmask) >> rightshift;
4681       b = (x & howto->src_mask & addrmask) >> bitpos;
4682
4683       switch (howto->complain_on_overflow)
4684         {
4685         case complain_overflow_signed:
4686           /* If any sign bits are set, all sign bits must be set.
4687              That is, A must be a valid negative address after
4688              shifting.  */
4689           signmask = ~(fieldmask >> 1);
4690           /* Fall through.  */
4691
4692         case complain_overflow_bitfield:
4693           /* Much like the signed check, but for a field one bit
4694              wider.  We allow a bitfield to represent numbers in the
4695              range -2**n to 2**n-1, where n is the number of bits in the
4696              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
4697              can't overflow, which is exactly what we want.  */
4698           ss = a & signmask;
4699           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4700             flag = bfd_reloc_overflow;
4701
4702           /* We only need this next bit of code if the sign bit of B
4703              is below the sign bit of A.  This would only happen if
4704              SRC_MASK had fewer bits than BITSIZE.  Note that if
4705              SRC_MASK has more bits than BITSIZE, we can get into
4706              trouble; we would need to verify that B is in range, as
4707              we do for A above.  */
4708           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4709           ss >>= bitpos;
4710
4711           /* Set all the bits above the sign bit.  */
4712           b = (b ^ ss) - ss;
4713
4714           /* Now we can do the addition.  */
4715           sum = a + b;
4716
4717           /* See if the result has the correct sign.  Bits above the
4718              sign bit are junk now; ignore them.  If the sum is
4719              positive, make sure we did not have all negative inputs;
4720              if the sum is negative, make sure we did not have all
4721              positive inputs.  The test below looks only at the sign
4722              bits, and it really just
4723              SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4724
4725              We mask with addrmask here to explicitly allow an address
4726              wrap-around.  The Linux kernel relies on it, and it is
4727              the only way to write assembler code which can run when
4728              loaded at a location 0x80000000 away from the location at
4729              which it is linked.  */
4730           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4731             flag = bfd_reloc_overflow;
4732
4733           break;
4734
4735         case complain_overflow_unsigned:
4736           /* Checking for an unsigned overflow is relatively easy:
4737              trim the addresses and add, and trim the result as well.
4738              Overflow is normally indicated when the result does not
4739              fit in the field.  However, we also need to consider the
4740              case when, e.g., fieldmask is 0x7fffffff or smaller, an
4741              input is 0x80000000, and bfd_vma is only 32 bits; then we
4742              will get sum == 0, but there is an overflow, since the
4743              inputs did not fit in the field.  Instead of doing a
4744              separate test, we can check for this by or-ing in the
4745              operands when testing for the sum overflowing its final
4746              field.  */
4747           sum = (a + b) & addrmask;
4748           if ((a | b | sum) & signmask)
4749             flag = bfd_reloc_overflow;
4750           break;
4751
4752         default:
4753           abort ();
4754         }
4755     }
4756
4757   /* Put RELOCATION in the right bits.  */
4758   relocation >>= (bfd_vma) rightshift;
4759   relocation <<= (bfd_vma) bitpos;
4760
4761   /* Add RELOCATION to the right bits of X.  */
4762   /* FIXME : 090616
4763      Because the relaxation may generate duplicate relocation at one address,
4764      an addition to immediate in the instruction may cause the relocation added
4765      several times.
4766      This bug should be fixed in assembler, but a check is also needed here.  */
4767   if (howto->partial_inplace)
4768     x = ((x & ~howto->dst_mask)
4769          | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4770   else
4771     x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4772
4773
4774   /* Put the relocated value back in the object file.  */
4775   switch (size)
4776     {
4777     default:
4778     case 0:
4779     case 1:
4780     case 8:
4781       abort ();
4782       break;
4783     case 2:
4784       bfd_putb16 (x, location);
4785       break;
4786     case 4:
4787       bfd_putb32 (x, location);
4788       break;
4789     }
4790
4791   return flag;
4792 }
4793
4794 static bfd_reloc_status_type
4795 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4796                                asection *input_section, bfd_byte *contents,
4797                                bfd_vma address, bfd_vma value, bfd_vma addend)
4798 {
4799   bfd_vma relocation;
4800
4801   /* Sanity check the address.  */
4802   if (address > bfd_get_section_limit (input_bfd, input_section))
4803     return bfd_reloc_outofrange;
4804
4805   /* This function assumes that we are dealing with a basic relocation
4806      against a symbol.  We want to compute the value of the symbol to
4807      relocate to.  This is just VALUE, the value of the symbol, plus
4808      ADDEND, any addend associated with the reloc.  */
4809   relocation = value + addend;
4810
4811   /* If the relocation is PC relative, we want to set RELOCATION to
4812      the distance between the symbol (currently in RELOCATION) and the
4813      location we are relocating.  If pcrel_offset is FALSE we do not
4814      need to subtract out the offset of the location within the
4815      section (which is just ADDRESS).  */
4816   if (howto->pc_relative)
4817     {
4818       relocation -= (input_section->output_section->vma
4819                      + input_section->output_offset);
4820       if (howto->pcrel_offset)
4821         relocation -= address;
4822     }
4823
4824   return nds32_relocate_contents (howto, input_bfd, relocation,
4825                                   contents + address);
4826 }
4827
4828 static bfd_boolean
4829 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4830                               const char *name,
4831                               Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4832                               asection *input_sec,
4833                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4834 {
4835   const char *source;
4836   FILE *sym_ld_script = NULL;
4837   struct elf_nds32_link_hash_table *table;
4838
4839   table = nds32_elf_hash_table (info);
4840   sym_ld_script = table->sym_ld_script;
4841   if (!sym_ld_script)
4842     return TRUE;
4843
4844   if (!h || !name || *name == '\0')
4845     return TRUE;
4846
4847   if (input_sec->flags & SEC_EXCLUDE)
4848     return TRUE;
4849
4850   if (!check_start_export_sym)
4851     {
4852       fprintf (sym_ld_script, "SECTIONS\n{\n");
4853       check_start_export_sym = 1;
4854     }
4855
4856   if (h->root.type == bfd_link_hash_defined
4857       || h->root.type == bfd_link_hash_defweak)
4858     {
4859       if (!h->root.u.def.section->output_section)
4860         return TRUE;
4861
4862       if (bfd_is_const_section (input_sec))
4863         source = input_sec->name;
4864       else
4865         source = bfd_get_filename (input_sec->owner);
4866
4867       fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4868                h->root.root.string,
4869                (long) (h->root.u.def.value
4870                 + h->root.u.def.section->output_section->vma
4871                 + h->root.u.def.section->output_offset), source);
4872     }
4873
4874   return TRUE;
4875 }
4876
4877 /* Relocate an NDS32/D ELF section.
4878    There is some attempt to make this function usable for many architectures,
4879    both for RELA and REL type relocs, if only to serve as a learning tool.
4880
4881    The RELOCATE_SECTION function is called by the new ELF backend linker
4882    to handle the relocations for a section.
4883
4884    The relocs are always passed as Rela structures; if the section
4885    actually uses Rel structures, the r_addend field will always be
4886    zero.
4887
4888    This function is responsible for adjust the section contents as
4889    necessary, and (if using Rela relocs and generating a
4890    relocatable output file) adjusting the reloc addend as
4891    necessary.
4892
4893    This function does not have to worry about setting the reloc
4894    address or the reloc symbol index.
4895
4896    LOCAL_SYMS is a pointer to the swapped in local symbols.
4897
4898    LOCAL_SECTIONS is an array giving the section in the input file
4899    corresponding to the st_shndx field of each local symbol.
4900
4901    The global hash table entry for the global symbols can be found
4902    via elf_sym_hashes (input_bfd).
4903
4904    When generating relocatable output, this function must handle
4905    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
4906    going to be the section symbol corresponding to the output
4907    section, which means that the addend must be adjusted
4908    accordingly.  */
4909
4910 /* Return the base VMA address which should be subtracted from real addresses
4911    when resolving @dtpoff relocation.
4912    This is PT_TLS segment p_vaddr.  */
4913
4914 /* Return the relocation value for @tpoff relocation
4915    if STT_TLS virtual address is ADDRESS.  */
4916
4917 /* Return the relocation value for @gottpoff relocation
4918    if STT_TLS virtual address is ADDRESS.  */
4919
4920 static bfd_vma
4921 gottpoff (struct bfd_link_info *info, bfd_vma address)
4922 {
4923   bfd_vma tp_base;
4924   bfd_vma tp_offset;
4925
4926   /* If tls_sec is NULL, we should have signalled an error already.  */
4927   if (elf_hash_table (info)->tls_sec == NULL)
4928     return 0;
4929
4930   tp_base = elf_hash_table (info)->tls_sec->vma;
4931   tp_offset = address - tp_base;
4932
4933   return tp_offset;
4934 }
4935
4936 static bfd_boolean
4937 patch_tls_desc_to_ie (bfd_byte *contents, Elf_Internal_Rela *rel, bfd *ibfd)
4938 {
4939   /* TLS_GD/TLS_LD model #1
4940      46 00 00 00 sethi $r0,#0x0
4941      58 00 00 00 ori $r0,$r0,#0x0
4942      40 00 74 00 add $r0,$r0,$gp
4943      04 10 00 00 lwi $r1,[$r0+#0x0]
4944      4b e0 04 01 jral $lp,$r1  */
4945
4946   /* TLS_GD/TLS_LD model #2
4947      46 00 00 00 sethi $r0,#0x0
4948      58 00 00 00 ori $r0,$r0,#0x0
4949      38 10 74 02 lw $r1,[$r0+($gp<<#0x0)]
4950      40 00 74 00 add $r0,$r0,$gp
4951      4b e0 04 01 jral $lp,$r1  */
4952
4953   /* TLS_IE model (non-PIC)
4954      46 00 00 00 sethi $r0,#0x0
4955      04 00 00 00 lwi $r0,[$r0+#0x0]
4956      38 00 64 02 lw $r0,[$r0+($r25<<#0x0)]  */
4957
4958   /* TLS_IE model (PIC)
4959      46 00 00 00 sethi $r0,#0x0
4960      58 00 00 00 ori $r0,$r0,#0x0
4961      38 00 74 02 lw $r0,[$r0+($gp<<#0x0)]
4962      38 00 64 02 lw $r0,[$r0+($r25<<#0x0)]  */
4963
4964   /* TLS_GD_TO_IE model
4965      46 00 00 00 sethi $r0,#0x0
4966      58 00 00 00 ori $r0,$r0,#0x0
4967      40 00 74 00 add $r0,$rM,$gp
4968      04 00 00 01 lwi $r0,[$r0+#0x4]
4969      40 00 64 00 add $r0,$r0,$r25  */
4970
4971   bfd_boolean rz = FALSE;
4972
4973   typedef struct
4974     {
4975       uint32_t opcode;
4976       uint32_t mask;
4977     } pat_t;
4978
4979   uint32_t patch[3] =
4980     {
4981       0x40007400, /* add $r0,$rM,$gp     */
4982       0x04000001, /* lwi $r0,[$r0+#0x4]  */
4983       0x40006400, /* add $r0,$r0,$r25    */
4984     };
4985
4986   pat_t mode0[3] =
4987     {
4988         { 0x40000000, 0xfe0003ff },
4989         { 0x04000000, 0xfe000000 },
4990         { 0x4be00001, 0xffff83ff },
4991     };
4992
4993   pat_t mode1[3] =
4994     {
4995         { 0x38007402, 0xfe007fff },
4996         { 0x40007400, 0xfe007fff },
4997         { 0x4be00001, 0xffff83ff },
4998     };
4999
5000   unsigned char *p = contents + rel->r_offset;
5001
5002   uint32_t insn;
5003   uint32_t regidx = 0;
5004   insn = bfd_getb32 (p);
5005   if (INSN_SETHI == (0xfe0fffffu & insn))
5006     {
5007       regidx = 0x1f & (insn >> 20);
5008       p += 4;
5009     }
5010
5011   insn = bfd_getb32 (p);
5012   if (INSN_ORI == (0xfe007fffu & insn))
5013     {
5014       regidx = 0x1f & (insn >> 20);
5015       p += 4;
5016     }
5017
5018   if (patch[2] == bfd_getb32 (p + 8)) /* Character instruction.  */
5019     {
5020       /* already patched?  */
5021       if ((patch[0] == (0xfff07fffu & bfd_getb32 (p + 0))) &&
5022           (patch[1] == bfd_getb32 (p + 4)))
5023         rz = TRUE;
5024     }
5025   else if (mode0[0].opcode == (mode0[0].mask & bfd_getb32 (p + 0)))
5026     {
5027       if ((mode0[1].opcode == (mode0[1].mask & bfd_getb32 (p + 4))) &&
5028           (mode0[2].opcode == (mode0[2].mask & bfd_getb32 (p + 8))))
5029         {
5030           bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5031           bfd_putb32 (patch[1], p + 4);
5032           bfd_putb32 (patch[2], p + 8);
5033           rz = TRUE;
5034         }
5035     }
5036   else if (mode1[0].opcode == (mode1[0].mask & bfd_getb32 (p + 0)))
5037     {
5038       if ((mode1[1].opcode == (mode1[1].mask & bfd_getb32 (p + 4))) &&
5039           (mode1[2].opcode == (mode1[2].mask & bfd_getb32 (p + 8))))
5040         {
5041           bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5042           bfd_putb32 (patch[1], p + 4);
5043           bfd_putb32 (patch[2], p + 8);
5044           rz = TRUE;
5045         }
5046     }
5047
5048   if (!rz)
5049     {
5050       printf ("%s: %s @ 0x%08x\n", __func__, bfd_get_filename (ibfd),
5051               (int) rel->r_offset);
5052       BFD_ASSERT(0); /* Unsupported pattern.  */
5053     }
5054
5055   return rz;
5056 }
5057
5058 static enum elf_nds32_tls_type
5059 get_tls_type (enum elf_nds32_reloc_type r_type, struct elf_link_hash_entry *h);
5060
5061 static unsigned int
5062 ones32 (register unsigned int x)
5063 {
5064   /* 32-bit recursive reduction using SWAR...
5065      but first step is mapping 2-bit values
5066      into sum of 2 1-bit values in sneaky way.  */
5067   x -= ((x >> 1) & 0x55555555);
5068   x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
5069   x = (((x >> 4) + x) & 0x0f0f0f0f);
5070   x += (x >> 8);
5071   x += (x >> 16);
5072   return (x & 0x0000003f);
5073 }
5074
5075 #if !HAVE_FLS
5076 static unsigned int
5077 fls (register unsigned int x)
5078 {
5079   return ffs (x & (-x));
5080 }
5081 #endif /* !HAVE_FLS */
5082
5083 #define nds32_elf_local_tlsdesc_gotent(bfd) \
5084   (elf_nds32_tdata (bfd)->local_tlsdesc_gotent)
5085
5086 static bfd_boolean
5087 nds32_elf_relocate_section (bfd *                  output_bfd ATTRIBUTE_UNUSED,
5088                             struct bfd_link_info * info,
5089                             bfd *                  input_bfd,
5090                             asection *             input_section,
5091                             bfd_byte *             contents,
5092                             Elf_Internal_Rela *    relocs,
5093                             Elf_Internal_Sym *     local_syms,
5094                             asection **            local_sections)
5095 {
5096   Elf_Internal_Shdr *symtab_hdr;
5097   struct elf_link_hash_entry **sym_hashes;
5098   Elf_Internal_Rela *rel, *relend;
5099   bfd_boolean ret = TRUE;               /* Assume success.  */
5100   int align = 0;
5101   bfd_reloc_status_type r;
5102   const char *errmsg = NULL;
5103   bfd_vma gp;
5104   struct elf_link_hash_table *ehtab;
5105   struct elf_nds32_link_hash_table *htab;
5106   bfd *dynobj;
5107   bfd_vma *local_got_offsets;
5108   asection *sgot, *splt, *sreloc;
5109   bfd_vma high_address;
5110   struct elf_nds32_link_hash_table *table;
5111   int eliminate_gc_relocs;
5112   bfd_vma fpbase_addr;
5113
5114   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5115   sym_hashes = elf_sym_hashes (input_bfd);
5116   ehtab = elf_hash_table (info);
5117   htab = nds32_elf_hash_table (info);
5118   high_address = bfd_get_section_limit (input_bfd, input_section);
5119
5120   dynobj = htab->root.dynobj;
5121   local_got_offsets = elf_local_got_offsets (input_bfd);
5122
5123   sgot = ehtab->sgot;
5124   splt = ehtab->splt;
5125   sreloc = NULL;
5126
5127   rel = relocs;
5128   relend = relocs + input_section->reloc_count;
5129
5130   table = nds32_elf_hash_table (info);
5131   eliminate_gc_relocs = table->eliminate_gc_relocs;
5132
5133   /* By this time, we can adjust the value of _SDA_BASE_.  */
5134   /* Explain _SDA_BASE_  */
5135   if ((!bfd_link_relocatable (info)))
5136     {
5137       is_SDA_BASE_set = 1;
5138       r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
5139       if (r != bfd_reloc_ok)
5140         return FALSE;
5141     }
5142
5143   /* Do TLS model conversion once at first.  */
5144   nds32_elf_unify_tls_model (input_bfd, input_section, contents, info);
5145
5146   /* Use gp as fp to prevent truncated fit.  Because in relaxation time
5147      the fp value is set as gp, and it has be reverted for instruction
5148      setting fp.  */
5149   fpbase_addr = elf_gp (output_bfd);
5150
5151   /* Deal with (dynamic) relocations.  */
5152   for (rel = relocs; rel < relend; rel++)
5153     {
5154       enum elf_nds32_reloc_type r_type;
5155       reloc_howto_type *howto = NULL;
5156       unsigned long r_symndx;
5157       struct elf_link_hash_entry *h = NULL;
5158       Elf_Internal_Sym *sym = NULL;
5159       asection *sec;
5160       bfd_vma relocation;
5161       bfd_vma relocation_sym = 0xdeadbeef;
5162       Elf_Internal_Rela *lorel;
5163       bfd_vma off;
5164
5165       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
5166          ensure it's zero (we use REL relocs, not RELA).  Therefore this
5167          should be assigning zero to `addend', but for clarity we use
5168          `r_addend'.  */
5169
5170       bfd_vma addend = rel->r_addend;
5171       bfd_vma offset = rel->r_offset;
5172
5173       r_type = ELF32_R_TYPE (rel->r_info);
5174       if (r_type >= R_NDS32_max)
5175         {
5176           /* xgettext:c-format */
5177           _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
5178                               input_bfd, r_type);
5179           bfd_set_error (bfd_error_bad_value);
5180           ret = FALSE;
5181           continue;
5182         }
5183
5184       if (r_type == R_NDS32_GNU_VTENTRY
5185           || r_type == R_NDS32_GNU_VTINHERIT
5186           || r_type == R_NDS32_NONE
5187           || r_type == R_NDS32_RELA_GNU_VTENTRY
5188           || r_type == R_NDS32_RELA_GNU_VTINHERIT
5189           || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
5190           || r_type == R_NDS32_DATA
5191           || r_type == R_NDS32_TRAN)
5192         continue;
5193
5194       /* If we enter the fp-as-gp region.  Resolve the address
5195          of best fp-base.  */
5196       if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
5197           && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5198         {
5199           int dist;
5200
5201           /* Distance to relocation of best fp-base is encoded in R_SYM.  */
5202           dist =  rel->r_addend >> 16;
5203           fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
5204                                                   local_syms, symtab_hdr);
5205         }
5206       else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
5207                && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5208         {
5209           fpbase_addr = elf_gp (output_bfd);
5210         }
5211
5212       /* Skip the relocations used for relaxation.  */
5213       /* We have to update LONGCALL and LONGJUMP
5214          relocations when generating the relocatable files.  */
5215       if (!bfd_link_relocatable (info)
5216           && (r_type >= R_NDS32_RELAX_ENTRY
5217               || (r_type >= R_NDS32_LONGCALL4
5218                   && r_type <= R_NDS32_LONGJUMP7)))
5219         continue;
5220
5221       howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
5222       r_symndx = ELF32_R_SYM (rel->r_info);
5223
5224       /* This is a final link.  */
5225       sym = NULL;
5226       sec = NULL;
5227       h = NULL;
5228
5229       if (r_symndx < symtab_hdr->sh_info)
5230         {
5231           /* Local symbol.  */
5232           sym = local_syms + r_symndx;
5233           sec = local_sections[r_symndx];
5234
5235           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5236           addend = rel->r_addend;
5237
5238           /* keep symbol location for static TLS_IE GOT entry  */
5239           relocation_sym = relocation;
5240           if (bfd_link_relocatable (info))
5241             {
5242               /* This is a relocatable link.  We don't have to change
5243                  anything, unless the reloc is against a section symbol,
5244                  in which case we have to adjust according to where the
5245                  section symbol winds up in the output section.  */
5246               if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5247                 rel->r_addend += sec->output_offset + sym->st_value;
5248
5249               continue;
5250             }
5251         }
5252       else
5253         {
5254           /* External symbol.  */
5255           if (bfd_link_relocatable (info))
5256             continue;
5257           bfd_boolean warned, ignored, unresolved_reloc;
5258           int symndx = r_symndx - symtab_hdr->sh_info;
5259
5260           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5261                                    r_symndx, symtab_hdr, sym_hashes, h, sec,
5262                                    relocation, unresolved_reloc, warned,
5263                                    ignored);
5264
5265           /* keep symbol location for static TLS_IE GOT entry  */
5266           relocation_sym = relocation;
5267
5268           /* la $fp, _FP_BASE_ is per-function (region).
5269              Handle it specially.  */
5270           switch ((int) r_type)
5271             {
5272             case R_NDS32_HI20_RELA:
5273             case R_NDS32_LO12S0_RELA:
5274               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5275                           FP_BASE_NAME) == 0)
5276                 {
5277                   if (!bfd_link_pie (info))
5278                     {
5279                       _bfd_error_handler
5280                         ("%pB: warning: _FP_BASE_ setting insns relaxation failed.",
5281                          input_bfd);
5282                     }
5283                   relocation = fpbase_addr;
5284                 }
5285               break;
5286             case R_NDS32_SDA19S0_RELA:
5287             case R_NDS32_SDA15S0_RELA:
5288             case R_NDS32_20_RELA:
5289               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5290                           FP_BASE_NAME) == 0)
5291                 {
5292                   relocation = fpbase_addr;
5293                   break;
5294                 }
5295             }
5296         }
5297
5298       /* Sanity check the address.  */
5299       if (offset > high_address)
5300         {
5301           r = bfd_reloc_outofrange;
5302           goto check_reloc;
5303         }
5304
5305       if (r_type >= R_NDS32_RELAX_ENTRY)
5306         continue;
5307
5308       switch ((int) r_type)
5309         {
5310         case R_NDS32_GOTOFF:
5311           /* Relocation is relative to the start of the global offset
5312              table (for ld24 rx, #uimm24), e.g. access at label+addend
5313
5314              ld24 rx. #label@GOTOFF + addend
5315              sub  rx, r12.  */
5316         case R_NDS32_GOTOFF_HI20:
5317         case R_NDS32_GOTOFF_LO12:
5318         case R_NDS32_GOTOFF_LO15:
5319         case R_NDS32_GOTOFF_LO19:
5320           BFD_ASSERT (sgot != NULL);
5321
5322           relocation -= elf_gp (output_bfd);
5323           break;
5324
5325         case R_NDS32_9_PLTREL:
5326         case R_NDS32_25_PLTREL:
5327           /* Relocation is to the entry for this symbol in the
5328              procedure linkage table.  */
5329
5330           /* The native assembler will generate a 25_PLTREL reloc
5331              for a local symbol if you assemble a call from one
5332              section to another when using -K pic.  */
5333           if (h == NULL)
5334             break;
5335
5336           if (h->forced_local)
5337             break;
5338
5339           /* We didn't make a PLT entry for this symbol.  This
5340              happens when statically linking PIC code, or when
5341              using -Bsymbolic.  */
5342           if (h->plt.offset == (bfd_vma) - 1)
5343             break;
5344
5345           relocation = (splt->output_section->vma
5346                         + splt->output_offset + h->plt.offset);
5347           break;
5348
5349         case R_NDS32_PLT_GOTREL_HI20:
5350         case R_NDS32_PLT_GOTREL_LO12:
5351         case R_NDS32_PLT_GOTREL_LO15:
5352         case R_NDS32_PLT_GOTREL_LO19:
5353         case R_NDS32_PLT_GOTREL_LO20:
5354           if (h == NULL
5355               || h->forced_local
5356               || h->plt.offset == (bfd_vma) -1
5357               || (bfd_link_pie (info) && h->def_regular))
5358             {
5359               /* Maybe we should find better checking to optimize
5360                  PIE PLT relocations.  */
5361               /* We didn't make a PLT entry for this symbol.  This
5362                  happens when statically linking PIC code, or when
5363                  using -Bsymbolic.  */
5364               if (h)
5365                 h->plt.offset = (bfd_vma) -1;   /* Cancel PLT trampoline.  */
5366               relocation -= elf_gp (output_bfd);
5367               break;
5368             }
5369
5370           relocation = (splt->output_section->vma
5371                         + splt->output_offset + h->plt.offset);
5372
5373           relocation -= elf_gp (output_bfd);
5374           break;
5375
5376         case R_NDS32_PLTREL_HI20:
5377         case R_NDS32_PLTREL_LO12:
5378
5379           /* Relocation is to the entry for this symbol in the
5380              procedure linkage table.  */
5381
5382           /* The native assembler will generate a 25_PLTREL reloc
5383              for a local symbol if you assemble a call from one
5384              section to another when using -K pic.  */
5385           if (h == NULL)
5386             break;
5387
5388           if (h->forced_local)
5389             break;
5390
5391           if (h->plt.offset == (bfd_vma) - 1)
5392             /* We didn't make a PLT entry for this symbol.  This
5393                happens when statically linking PIC code, or when
5394                using -Bsymbolic.  */
5395             break;
5396
5397           if (splt == NULL)
5398             break;
5399
5400           relocation = (splt->output_section->vma
5401                         + splt->output_offset
5402                         + h->plt.offset + 4)
5403                        - (input_section->output_section->vma
5404                           + input_section->output_offset
5405                           + rel->r_offset);
5406
5407           break;
5408
5409         case R_NDS32_GOTPC20:
5410           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5411              ld24 rx,#_GLOBAL_OFFSET_TABLE_  */
5412           relocation = elf_gp (output_bfd);
5413           break;
5414
5415         case R_NDS32_GOTPC_HI20:
5416         case R_NDS32_GOTPC_LO12:
5417           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5418              bl .+4
5419              seth rx,#high(_GLOBAL_OFFSET_TABLE_)
5420              or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
5421              or
5422              bl .+4
5423              seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
5424              add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)  */
5425           relocation = elf_gp (output_bfd);
5426           relocation -= (input_section->output_section->vma
5427                          + input_section->output_offset + rel->r_offset);
5428           break;
5429
5430         case R_NDS32_GOT20:
5431           /* Fall through.  */
5432         case R_NDS32_GOT_HI20:
5433         case R_NDS32_GOT_LO12:
5434         case R_NDS32_GOT_LO15:
5435         case R_NDS32_GOT_LO19:
5436           /* Relocation is to the entry for this symbol in the global
5437              offset table.  */
5438           BFD_ASSERT (sgot != NULL);
5439
5440           if (h != NULL)
5441             {
5442               /* External symbol  */
5443               bfd_boolean dyn;
5444
5445               off = h->got.offset;
5446               BFD_ASSERT (off != (bfd_vma) - 1);
5447               dyn = htab->root.dynamic_sections_created;
5448               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
5449                                                     bfd_link_pic (info),
5450                                                     h)
5451                   || (bfd_link_pic (info)
5452                       && (info->symbolic
5453                           || h->dynindx == -1
5454                           || h->forced_local) && h->def_regular))
5455                 {
5456                   /* This is actually a static link, or it is a
5457                      -Bsymbolic link and the symbol is defined
5458                      locally, or the symbol was forced to be local
5459                      because of a version file.  We must initialize
5460                      this entry in the global offset table.  Since the
5461                      offset must always be a multiple of 4, we use the
5462                      least significant bit to record whether we have
5463                      initialized it already.
5464
5465                      When doing a dynamic link, we create a .rela.got
5466                      relocation entry to initialize the value.  This
5467                      is done in the finish_dynamic_symbol routine.  */
5468                   if ((off & 1) != 0)   /* clear LSB  */
5469                     off &= ~1;
5470                   else
5471                     {
5472                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5473                       h->got.offset |= 1;
5474                     }
5475                 }
5476               relocation = sgot->output_section->vma + sgot->output_offset + off
5477                            - elf_gp (output_bfd);
5478             }
5479           else
5480             {
5481               /* Local symbol  */
5482               bfd_byte *loc;
5483
5484               BFD_ASSERT (local_got_offsets != NULL
5485                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5486
5487               off = local_got_offsets[r_symndx];
5488
5489               /* The offset must always be a multiple of 4.  We use
5490                  the least significant bit to record whether we have
5491                  already processed this entry.  */
5492               if ((off & 1) != 0)       /* clear LSB  */
5493                 off &= ~1;
5494               else
5495                 {
5496                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5497
5498                   if (bfd_link_pic (info))
5499                     {
5500                       asection *srelgot;
5501                       Elf_Internal_Rela outrel;
5502
5503                       /* We need to generate a R_NDS32_RELATIVE reloc
5504                          for the dynamic linker.  */
5505                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5506                       BFD_ASSERT (srelgot != NULL);
5507
5508                       outrel.r_offset = (elf_gp (output_bfd)
5509                                          + sgot->output_offset + off);
5510                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5511                       outrel.r_addend = relocation;
5512                       loc = srelgot->contents;
5513                       loc +=
5514                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
5515                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5516                       ++srelgot->reloc_count;
5517                     }
5518                   local_got_offsets[r_symndx] |= 1;
5519                 }
5520               relocation = sgot->output_section->vma + sgot->output_offset + off
5521                            - elf_gp (output_bfd);
5522             }
5523
5524           break;
5525
5526         case R_NDS32_16_RELA:
5527         case R_NDS32_20_RELA:
5528         case R_NDS32_5_RELA:
5529         case R_NDS32_32_RELA:
5530         case R_NDS32_9_PCREL_RELA:
5531         case R_NDS32_WORD_9_PCREL_RELA:
5532         case R_NDS32_10_UPCREL_RELA:
5533         case R_NDS32_15_PCREL_RELA:
5534         case R_NDS32_17_PCREL_RELA:
5535         case R_NDS32_25_PCREL_RELA:
5536         case R_NDS32_HI20_RELA:
5537         case R_NDS32_LO12S3_RELA:
5538         case R_NDS32_LO12S2_RELA:
5539         case R_NDS32_LO12S2_DP_RELA:
5540         case R_NDS32_LO12S2_SP_RELA:
5541         case R_NDS32_LO12S1_RELA:
5542         case R_NDS32_LO12S0_RELA:
5543         case R_NDS32_LO12S0_ORI_RELA:
5544           if (bfd_link_pic (info) && r_symndx != 0
5545               && (input_section->flags & SEC_ALLOC) != 0
5546               && (eliminate_gc_relocs == 0
5547                   || (sec && (sec->flags & SEC_EXCLUDE) == 0))
5548               && ((r_type != R_NDS32_9_PCREL_RELA
5549                    && r_type != R_NDS32_WORD_9_PCREL_RELA
5550                    && r_type != R_NDS32_10_UPCREL_RELA
5551                    && r_type != R_NDS32_15_PCREL_RELA
5552                    && r_type != R_NDS32_17_PCREL_RELA
5553                    && r_type != R_NDS32_25_PCREL_RELA
5554                    && !(r_type == R_NDS32_32_RELA
5555                         && strcmp (input_section->name, ".eh_frame") == 0))
5556                   || (h != NULL && h->dynindx != -1
5557                       && (!info->symbolic || !h->def_regular))))
5558             {
5559               Elf_Internal_Rela outrel;
5560               bfd_boolean skip, relocate;
5561               bfd_byte *loc;
5562
5563               /* When generating a shared object, these relocations
5564                  are copied into the output file to be resolved at run
5565                  time.  */
5566
5567               if (sreloc == NULL)
5568                 {
5569                   const char *name;
5570
5571                   name = bfd_elf_string_from_elf_section
5572                     (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
5573                      elf_section_data (input_section)->rela.hdr->sh_name);
5574                   if (name == NULL)
5575                     return FALSE;
5576
5577                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5578                               && strcmp (bfd_section_name (input_section),
5579                                          name + 5) == 0);
5580
5581                   sreloc = bfd_get_section_by_name (dynobj, name);
5582                   BFD_ASSERT (sreloc != NULL);
5583                 }
5584
5585               skip = FALSE;
5586               relocate = FALSE;
5587
5588               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5589                                                          info,
5590                                                          input_section,
5591                                                          rel->r_offset);
5592               if (outrel.r_offset == (bfd_vma) - 1)
5593                 skip = TRUE;
5594               else if (outrel.r_offset == (bfd_vma) - 2)
5595                 skip = TRUE, relocate = TRUE;
5596               outrel.r_offset += (input_section->output_section->vma
5597                                   + input_section->output_offset);
5598
5599               if (skip)
5600                 memset (&outrel, 0, sizeof outrel);
5601               else if (r_type == R_NDS32_17_PCREL_RELA
5602                        || r_type == R_NDS32_15_PCREL_RELA
5603                        || r_type == R_NDS32_25_PCREL_RELA)
5604                 {
5605                   BFD_ASSERT (h != NULL && h->dynindx != -1);
5606                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5607                   outrel.r_addend = rel->r_addend;
5608                 }
5609               else
5610                 {
5611                   /* h->dynindx may be -1 if this symbol was marked to
5612                      become local.  */
5613                   if (h == NULL
5614                       || ((info->symbolic || h->dynindx == -1)
5615                           && h->def_regular)
5616                       || (bfd_link_pie (info) && h->def_regular))
5617                     {
5618                       relocate = TRUE;
5619                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5620                       outrel.r_addend = relocation + rel->r_addend;
5621
5622                       if (h)
5623                         {
5624                           h->plt.offset = (bfd_vma) -1;   /* cancel PLT trampoline.  */
5625
5626                           BFD_ASSERT (sgot != NULL);
5627                           /* If we did not allocate got entry for the symbol,
5628                              we can not fill the nonexistent got entry.  */
5629                           if (h->got.offset != (bfd_vma) -1
5630                               && (h->got.offset & 1) == 0)
5631                             {
5632                               bfd_put_32 (output_bfd, outrel.r_addend,
5633                                           sgot->contents + h->got.offset);
5634                             }
5635                         }
5636                     }
5637                   else
5638                     {
5639                       if (h->dynindx == -1)
5640                         {
5641                           _bfd_error_handler
5642                             (_("%pB: relocation %s against `%s' can not be used when "
5643                                "making a shared object; recompile with -fPIC"),
5644                              input_bfd, nds32_elf_howto_table[r_type].name, h->root.root.string);
5645                           bfd_set_error (bfd_error_bad_value);
5646                           return FALSE;
5647                         }
5648
5649                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5650                       outrel.r_addend = rel->r_addend;
5651                     }
5652                 }
5653
5654               loc = sreloc->contents;
5655               loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
5656               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5657               ++sreloc->reloc_count;
5658
5659               /* If this reloc is against an external symbol, we do
5660                  not want to fiddle with the addend.  Otherwise, we
5661                  need to include the symbol value so that it becomes
5662                  an addend for the dynamic reloc.  */
5663               if (!relocate)
5664                 continue;
5665             }
5666           break;
5667
5668         case R_NDS32_25_ABS_RELA:
5669           if (bfd_link_pic (info))
5670             {
5671               _bfd_error_handler
5672                 (_("%pB: warning: %s unsupported in shared mode"),
5673                  input_bfd, "R_NDS32_25_ABS_RELA");
5674               return FALSE;
5675             }
5676           break;
5677
5678         case R_NDS32_9_PCREL:
5679           r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5680                                           contents, offset,
5681                                           sec, relocation, addend);
5682           goto check_reloc;
5683
5684         case R_NDS32_HI20:
5685           /* We allow an arbitrary number of HI20 relocs before the
5686              LO12 reloc.  This permits gcc to emit the HI and LO relocs
5687              itself.  */
5688           for (lorel = rel + 1;
5689                (lorel < relend
5690                 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5691             continue;
5692           if (lorel < relend
5693               && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5694                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5695                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5696                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5697             {
5698               nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5699                                        contents, relocation + addend);
5700               r = bfd_reloc_ok;
5701             }
5702           else
5703             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5704                                           contents, offset, relocation,
5705                                           addend);
5706           goto check_reloc;
5707
5708         case R_NDS32_GOT17S2_RELA:
5709         case R_NDS32_GOT15S2_RELA:
5710           BFD_ASSERT (sgot != NULL);
5711
5712           if (h != NULL)
5713             {
5714               bfd_boolean dyn;
5715
5716               off = h->got.offset;
5717               BFD_ASSERT (off != (bfd_vma) - 1);
5718
5719               dyn = htab->root.dynamic_sections_created;
5720               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5721                   (dyn, bfd_link_pic (info), h)
5722                   || (bfd_link_pic (info)
5723                       && (info->symbolic
5724                           || h->dynindx == -1
5725                           || h->forced_local)
5726                       && h->def_regular))
5727                 {
5728                   /* This is actually a static link, or it is a
5729                      -Bsymbolic link and the symbol is defined
5730                      locally, or the symbol was forced to be local
5731                      because of a version file.  We must initialize
5732                      this entry in the global offset table.  Since the
5733                      offset must always be a multiple of 4, we use the
5734                      least significant bit to record whether we have
5735                      initialized it already.
5736
5737                      When doing a dynamic link, we create a .rela.got
5738                      relocation entry to initialize the value.  This
5739                      is done in the finish_dynamic_symbol routine.  */
5740                   if ((off & 1) != 0)
5741                     off &= ~1;
5742                   else
5743                     {
5744                       bfd_put_32 (output_bfd, relocation,
5745                                   sgot->contents + off);
5746                       h->got.offset |= 1;
5747                     }
5748                 }
5749             }
5750           else
5751             {
5752               bfd_byte *loc;
5753
5754               BFD_ASSERT (local_got_offsets != NULL
5755                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5756
5757               off = local_got_offsets[r_symndx];
5758
5759               /* The offset must always be a multiple of 4.  We use
5760                  the least significant bit to record whether we have
5761                  already processed this entry.  */
5762               if ((off & 1) != 0)
5763                 off &= ~1;
5764               else
5765                 {
5766                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5767
5768                   if (bfd_link_pic (info))
5769                     {
5770                       asection *srelgot;
5771                       Elf_Internal_Rela outrel;
5772
5773                       /* We need to generate a R_NDS32_RELATIVE reloc
5774                          for the dynamic linker.  */
5775                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5776                       BFD_ASSERT (srelgot != NULL);
5777
5778                       outrel.r_offset = (elf_gp (output_bfd)
5779                                          + sgot->output_offset + off);
5780                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5781                       outrel.r_addend = relocation;
5782                       loc = srelgot->contents;
5783                       loc +=
5784                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
5785                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5786                       ++srelgot->reloc_count;
5787                     }
5788                   local_got_offsets[r_symndx] |= 1;
5789                 }
5790             }
5791           relocation = sgot->output_section->vma + sgot->output_offset + off
5792             - elf_gp (output_bfd);
5793
5794           if (relocation & align)
5795             {
5796               /* Incorrect alignment.  */
5797               _bfd_error_handler
5798                 (_("%pB: warning: unaligned access to GOT entry"), input_bfd);
5799               ret = FALSE;
5800               r = bfd_reloc_dangerous;
5801               goto check_reloc;
5802             }
5803           break;
5804
5805         case R_NDS32_SDA16S3_RELA:
5806         case R_NDS32_SDA15S3_RELA:
5807         case R_NDS32_SDA15S3:
5808           align = 0x7;
5809           goto handle_sda;
5810
5811         case R_NDS32_SDA17S2_RELA:
5812         case R_NDS32_SDA15S2_RELA:
5813         case R_NDS32_SDA12S2_SP_RELA:
5814         case R_NDS32_SDA12S2_DP_RELA:
5815         case R_NDS32_SDA15S2:
5816         case R_NDS32_SDA_FP7U2_RELA:
5817           align = 0x3;
5818           goto handle_sda;
5819
5820         case R_NDS32_SDA18S1_RELA:
5821         case R_NDS32_SDA15S1_RELA:
5822         case R_NDS32_SDA15S1:
5823           align = 0x1;
5824           goto handle_sda;
5825
5826         case R_NDS32_SDA19S0_RELA:
5827         case R_NDS32_SDA15S0_RELA:
5828         case R_NDS32_SDA15S0:
5829           align = 0x0;
5830         handle_sda:
5831           BFD_ASSERT (sec != NULL);
5832
5833           /* If the symbol is in the abs section, the out_bfd will be null.
5834              This happens when the relocation has a symbol@GOTOFF.  */
5835           r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5836           if (r != bfd_reloc_ok)
5837             {
5838               _bfd_error_handler
5839                 (_("%pB: warning: relocate SDA_BASE failed"), input_bfd);
5840               ret = FALSE;
5841               goto check_reloc;
5842             }
5843
5844           /* At this point `relocation' contains the object's
5845              address.  */
5846           if (r_type == R_NDS32_SDA_FP7U2_RELA)
5847             {
5848               relocation -= fpbase_addr;
5849             }
5850           else
5851             relocation -= gp;
5852           /* Now it contains the offset from _SDA_BASE_.  */
5853
5854           /* Make sure alignment is correct.  */
5855
5856           if (relocation & align)
5857             {
5858               /* Incorrect alignment.  */
5859               _bfd_error_handler
5860                 /* xgettext:c-format */
5861                 (_("%pB(%pA): warning: unaligned small data access"
5862                    " of type %d"),
5863                  input_bfd, input_section, r_type);
5864               ret = FALSE;
5865               goto check_reloc;
5866             }
5867           break;
5868
5869         case R_NDS32_17IFC_PCREL_RELA:
5870         case R_NDS32_10IFCU_PCREL_RELA:
5871           /* Do nothing.  */
5872           break;
5873
5874         case R_NDS32_TLS_LE_HI20:
5875         case R_NDS32_TLS_LE_LO12:
5876         case R_NDS32_TLS_LE_20:
5877         case R_NDS32_TLS_LE_15S0:
5878         case R_NDS32_TLS_LE_15S1:
5879         case R_NDS32_TLS_LE_15S2:
5880           /* We do not have garbage collection for got entries.
5881              Therefore, IE to LE may have one empty entry, and DESC to
5882              LE may have two.  */
5883           if (elf_hash_table (info)->tls_sec != NULL)
5884             relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5885           break;
5886
5887         case R_NDS32_TLS_IE_HI20:
5888         case R_NDS32_TLS_IE_LO12S2:
5889         case R_NDS32_TLS_DESC_HI20:
5890         case R_NDS32_TLS_DESC_LO12:
5891         case R_NDS32_TLS_IE_LO12:
5892         case R_NDS32_TLS_IEGP_HI20:
5893         case R_NDS32_TLS_IEGP_LO12:
5894         case R_NDS32_TLS_IEGP_LO12S2:
5895           {
5896             /* Relocation is to the entry for this symbol in the global
5897                offset table.  */
5898             enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
5899             asection *srelgot;
5900             Elf_Internal_Rela outrel;
5901             bfd_byte *loc;
5902             int indx = 0;
5903
5904             eff_tls_type = org_tls_type = get_tls_type (r_type, h);
5905
5906             BFD_ASSERT (sgot != NULL);
5907             if (h != NULL)
5908               {
5909                 bfd_boolean dyn;
5910
5911                 off = h->got.offset;
5912                 BFD_ASSERT (off != (bfd_vma) -1);
5913                 dyn = htab->root.dynamic_sections_created;
5914                 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5915                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5916                     && (!bfd_link_pic (info)
5917                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
5918                   indx = h->dynindx;
5919               }
5920             else
5921               {
5922                 BFD_ASSERT (local_got_offsets != NULL
5923                             && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5924                 off = local_got_offsets[r_symndx];
5925                 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5926               }
5927
5928             relocation = sgot->output_section->vma + sgot->output_offset + off;
5929
5930             if (1 < ones32 (tls_type))
5931               {
5932                 eff_tls_type = 1 << (fls (tls_type) - 1);
5933                 /* TLS model shall be handled in nds32_elf_unify_tls_model ().  */
5934
5935                 /* TLS model X -> LE is not implement yet!
5936                    workaround here!  */
5937                 if (eff_tls_type == GOT_TLS_LE)
5938                   {
5939                     eff_tls_type = 1 << (fls (tls_type ^ eff_tls_type) - 1);
5940                   }
5941               }
5942
5943             /* The offset must always be a multiple of 4.  We use
5944                the least significant bit to record whether we have
5945                already processed this entry.  */
5946             bfd_boolean need_relocs = FALSE;
5947             srelgot = ehtab->srelgot;
5948             if ((bfd_link_pic (info) || indx != 0)
5949                 && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5950                     || h->root.type != bfd_link_hash_undefweak))
5951               {
5952                 need_relocs = TRUE;
5953                 BFD_ASSERT (srelgot != NULL);
5954               }
5955
5956             if (off & 1)
5957               {
5958                 off &= ~1;
5959                 relocation &= ~1;
5960
5961                 if (eff_tls_type & GOT_TLS_DESC)
5962                   {
5963                     relocation -= elf_gp (output_bfd);
5964                     if ((R_NDS32_TLS_DESC_HI20 == r_type) && (!need_relocs))
5965                       {
5966                         /* TLS model shall be converted.  */
5967                         BFD_ASSERT(0);
5968                       }
5969                   }
5970                 else if (eff_tls_type & GOT_TLS_IEGP)
5971                   {
5972                     relocation -= elf_gp (output_bfd);
5973                   }
5974               }
5975             else
5976               {
5977                 if ((eff_tls_type & GOT_TLS_LE) && (tls_type ^ eff_tls_type))
5978                   {
5979                     /* TLS model workaround shall be applied.  */
5980                     BFD_ASSERT(0);
5981                   }
5982                 else if (eff_tls_type & (GOT_TLS_IE | GOT_TLS_IEGP))
5983                   {
5984                     if (eff_tls_type & GOT_TLS_IEGP)
5985                       relocation -= elf_gp(output_bfd);
5986
5987                     if (need_relocs)
5988                       {
5989                         if (indx == 0)
5990                           outrel.r_addend = gottpoff (info, relocation_sym);
5991                         else
5992                           outrel.r_addend = 0;
5993                         outrel.r_offset = (sgot->output_section->vma
5994                                            + sgot->output_offset + off);
5995                         outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_TPOFF);
5996
5997                         elf32_nds32_add_dynreloc (output_bfd, info, srelgot,
5998                                                   &outrel);
5999                       }
6000                     else
6001                       {
6002                         bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6003                                     sgot->contents + off);
6004                       }
6005                   }
6006                 else if (eff_tls_type & GOT_TLS_DESC)
6007                   {
6008                     relocation -= elf_gp (output_bfd);
6009                     if (need_relocs)
6010                       {
6011                         if (indx == 0)
6012                           outrel.r_addend = gottpoff (info, relocation_sym);
6013                         else
6014                           outrel.r_addend = 0;
6015                         outrel.r_offset = (sgot->output_section->vma
6016                                            + sgot->output_offset + off);
6017                         outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_DESC);
6018
6019                         if (htab->tls_desc_trampoline)
6020                           {
6021                             asection *srelplt;
6022                             srelplt = ehtab->srelplt;
6023                             loc = srelplt->contents;
6024                             loc += htab->next_tls_desc_index++ * sizeof (Elf32_External_Rela);
6025                             BFD_ASSERT (loc + sizeof (Elf32_External_Rela)
6026                                         <= srelplt->contents + srelplt->size);
6027
6028                             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6029                           }
6030                         else
6031                           {
6032                             loc = srelgot->contents;
6033                             loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
6034                             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6035                             ++srelgot->reloc_count;
6036                           }
6037                       }
6038                     else
6039                       {
6040                         /* feed me!  */
6041                         bfd_put_32 (output_bfd, 0xdeadbeef,
6042                                     sgot->contents + off);
6043                         bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6044                                     sgot->contents + off + 4);
6045                         patch_tls_desc_to_ie (contents, rel, input_bfd);
6046                         BFD_ASSERT(0);
6047                       }
6048                   }
6049                 else
6050                   {
6051                     /* TLS model workaround shall be applied.  */
6052                     BFD_ASSERT(0);
6053                   }
6054
6055                 if (h != NULL)
6056                   h->got.offset |= 1;
6057                 else
6058                   local_got_offsets[r_symndx] |= 1;
6059               }
6060           }
6061         break;
6062           /* DON'T fall through.  */
6063
6064         default:
6065           /* OLD_NDS32_RELOC.  */
6066
6067           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6068                                         contents, offset, relocation, addend);
6069           goto check_reloc;
6070         }
6071
6072       switch ((int) r_type)
6073         {
6074         case R_NDS32_20_RELA:
6075         case R_NDS32_5_RELA:
6076         case R_NDS32_9_PCREL_RELA:
6077         case R_NDS32_WORD_9_PCREL_RELA:
6078         case R_NDS32_10_UPCREL_RELA:
6079         case R_NDS32_15_PCREL_RELA:
6080         case R_NDS32_17_PCREL_RELA:
6081         case R_NDS32_25_PCREL_RELA:
6082         case R_NDS32_25_ABS_RELA:
6083         case R_NDS32_HI20_RELA:
6084         case R_NDS32_LO12S3_RELA:
6085         case R_NDS32_LO12S2_RELA:
6086         case R_NDS32_LO12S2_DP_RELA:
6087         case R_NDS32_LO12S2_SP_RELA:
6088         case R_NDS32_LO12S1_RELA:
6089         case R_NDS32_LO12S0_RELA:
6090         case R_NDS32_LO12S0_ORI_RELA:
6091         case R_NDS32_SDA16S3_RELA:
6092         case R_NDS32_SDA17S2_RELA:
6093         case R_NDS32_SDA18S1_RELA:
6094         case R_NDS32_SDA19S0_RELA:
6095         case R_NDS32_SDA15S3_RELA:
6096         case R_NDS32_SDA15S2_RELA:
6097         case R_NDS32_SDA12S2_DP_RELA:
6098         case R_NDS32_SDA12S2_SP_RELA:
6099         case R_NDS32_SDA15S1_RELA:
6100         case R_NDS32_SDA15S0_RELA:
6101         case R_NDS32_SDA_FP7U2_RELA:
6102         case R_NDS32_9_PLTREL:
6103         case R_NDS32_25_PLTREL:
6104         case R_NDS32_GOT20:
6105         case R_NDS32_GOT_HI20:
6106         case R_NDS32_GOT_LO12:
6107         case R_NDS32_GOT_LO15:
6108         case R_NDS32_GOT_LO19:
6109         case R_NDS32_GOT15S2_RELA:
6110         case R_NDS32_GOT17S2_RELA:
6111         case R_NDS32_GOTPC20:
6112         case R_NDS32_GOTPC_HI20:
6113         case R_NDS32_GOTPC_LO12:
6114         case R_NDS32_GOTOFF:
6115         case R_NDS32_GOTOFF_HI20:
6116         case R_NDS32_GOTOFF_LO12:
6117         case R_NDS32_GOTOFF_LO15:
6118         case R_NDS32_GOTOFF_LO19:
6119         case R_NDS32_PLTREL_HI20:
6120         case R_NDS32_PLTREL_LO12:
6121         case R_NDS32_PLT_GOTREL_HI20:
6122         case R_NDS32_PLT_GOTREL_LO12:
6123         case R_NDS32_PLT_GOTREL_LO15:
6124         case R_NDS32_PLT_GOTREL_LO19:
6125         case R_NDS32_PLT_GOTREL_LO20:
6126         case R_NDS32_17IFC_PCREL_RELA:
6127         case R_NDS32_10IFCU_PCREL_RELA:
6128         case R_NDS32_TLS_LE_HI20:
6129         case R_NDS32_TLS_LE_LO12:
6130         case R_NDS32_TLS_IE_HI20:
6131         case R_NDS32_TLS_IE_LO12S2:
6132         case R_NDS32_TLS_LE_20:
6133         case R_NDS32_TLS_LE_15S0:
6134         case R_NDS32_TLS_LE_15S1:
6135         case R_NDS32_TLS_LE_15S2:
6136         case R_NDS32_TLS_DESC_HI20:
6137         case R_NDS32_TLS_DESC_LO12:
6138         case R_NDS32_TLS_IE_LO12:
6139         case R_NDS32_TLS_IEGP_HI20:
6140         case R_NDS32_TLS_IEGP_LO12:
6141         case R_NDS32_TLS_IEGP_LO12S2:
6142           /* Instruction related relocs must handle endian properly.  */
6143           /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER.  */
6144           r = nds32_elf_final_link_relocate (howto, input_bfd,
6145                                              input_section, contents,
6146                                              rel->r_offset, relocation,
6147                                              rel->r_addend);
6148           break;
6149
6150         default:
6151           /* All other relocs can use default handler.  */
6152           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6153                                         contents, rel->r_offset,
6154                                         relocation, rel->r_addend);
6155           break;
6156         }
6157
6158     check_reloc:
6159
6160       if (r != bfd_reloc_ok)
6161         {
6162           /* FIXME: This should be generic enough to go in a utility.  */
6163           const char *name;
6164
6165           if (h != NULL)
6166             name = h->root.root.string;
6167           else
6168             {
6169               name = bfd_elf_string_from_elf_section
6170                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
6171               if (name == NULL || *name == '\0')
6172                 name = bfd_section_name (sec);
6173             }
6174
6175           if (errmsg != NULL)
6176             goto common_error;
6177
6178           switch (r)
6179             {
6180             case bfd_reloc_overflow:
6181               (*info->callbacks->reloc_overflow)
6182                 (info, (h ? &h->root : NULL), name, howto->name,
6183                  (bfd_vma) 0, input_bfd, input_section, offset);
6184               break;
6185
6186             case bfd_reloc_undefined:
6187               (*info->callbacks->undefined_symbol)
6188                 (info, name, input_bfd, input_section, offset, TRUE);
6189               break;
6190
6191             case bfd_reloc_outofrange:
6192               errmsg = _("internal error: out of range error");
6193               goto common_error;
6194
6195             case bfd_reloc_notsupported:
6196               errmsg = _("internal error: unsupported relocation error");
6197               goto common_error;
6198
6199             case bfd_reloc_dangerous:
6200               errmsg = _("internal error: dangerous error");
6201               goto common_error;
6202
6203             default:
6204               errmsg = _("internal error: unknown error");
6205               /* Fall through.  */
6206
6207             common_error:
6208               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
6209                                            input_section, offset);
6210               break;
6211             }
6212         }
6213     }
6214
6215   /* Resotre header size to avoid overflow load.  */
6216   if (elf_nds32_tdata (input_bfd)->hdr_size != 0)
6217     symtab_hdr->sh_size = elf_nds32_tdata (input_bfd)->hdr_size;
6218
6219   return ret;
6220 }
6221
6222 /* Finish up dynamic symbol handling.  We set the contents of various
6223    dynamic sections here.  */
6224
6225 static bfd_boolean
6226 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6227                                  struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
6228 {
6229   struct elf_link_hash_table *ehtab;
6230   struct elf_nds32_link_hash_entry *hent;
6231   bfd_byte *loc;
6232
6233   ehtab = elf_hash_table (info);
6234   hent = (struct elf_nds32_link_hash_entry *) h;
6235
6236   if (h->plt.offset != (bfd_vma) - 1)
6237     {
6238       asection *splt;
6239       asection *sgot;
6240       asection *srela;
6241
6242       bfd_vma plt_index;
6243       bfd_vma got_offset;
6244       bfd_vma local_plt_offset;
6245       Elf_Internal_Rela rela;
6246
6247       /* This symbol has an entry in the procedure linkage table.  Set
6248          it up.  */
6249
6250       BFD_ASSERT (h->dynindx != -1);
6251
6252       splt = ehtab->splt;
6253       sgot = ehtab->sgotplt;
6254       srela = ehtab->srelplt;
6255       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
6256
6257       /* Get the index in the procedure linkage table which
6258          corresponds to this symbol.  This is the index of this symbol
6259          in all the symbols for which we are making plt entries.  The
6260          first entry in the procedure linkage table is reserved.  */
6261       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
6262
6263       /* Get the offset into the .got table of the entry that
6264          corresponds to this function.  Each .got entry is 4 bytes.
6265          The first three are reserved.  */
6266       got_offset = (plt_index + 3) * 4;
6267
6268       /* Fill in the entry in the procedure linkage table.  */
6269       if (!bfd_link_pic (info))
6270         {
6271           unsigned long insn;
6272
6273           insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
6274                                       + sgot->output_offset + got_offset) >> 12)
6275                                     & 0xfffff);
6276           bfd_putb32 (insn, splt->contents + h->plt.offset);
6277
6278           insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
6279                                       + sgot->output_offset + got_offset) & 0x0fff)
6280                                     >> 2);
6281           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6282
6283           insn = PLT_ENTRY_WORD2;
6284           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6285
6286           insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
6287           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6288
6289           insn = PLT_ENTRY_WORD4
6290                  + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
6291           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6292           local_plt_offset = 12;
6293         }
6294       else
6295         {
6296           /* sda_base must be set at this time.  */
6297           unsigned long insn;
6298           long offset;
6299
6300           offset = sgot->output_section->vma + sgot->output_offset + got_offset
6301                    - elf_gp (output_bfd);
6302           insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
6303           bfd_putb32 (insn, splt->contents + h->plt.offset);
6304
6305           insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
6306           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6307
6308           insn = PLT_PIC_ENTRY_WORD2;
6309           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6310
6311           insn = PLT_PIC_ENTRY_WORD3;
6312           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6313
6314           insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
6315           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6316
6317           insn = PLT_PIC_ENTRY_WORD5
6318             + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
6319           bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
6320
6321           local_plt_offset = 16;
6322         }
6323
6324       /* Fill in the entry in the global offset table,
6325          so it will fall through to the next instruction for the first time.  */
6326       bfd_put_32 (output_bfd,
6327                   (splt->output_section->vma + splt->output_offset
6328                    + h->plt.offset + local_plt_offset),
6329                   sgot->contents + got_offset);
6330
6331       /* Fill in the entry in the .rela.plt section.  */
6332       rela.r_offset = (sgot->output_section->vma
6333                        + sgot->output_offset + got_offset);
6334       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
6335       rela.r_addend = 0;
6336       loc = srela->contents;
6337       loc += plt_index * sizeof (Elf32_External_Rela);
6338       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6339
6340       if (!h->def_regular)
6341         {
6342           /* Mark the symbol as undefined, rather than as defined in
6343              the .plt section.  Leave the value alone.  */
6344           sym->st_shndx = SHN_UNDEF;
6345           if (!h->ref_regular_nonweak)
6346             sym->st_value = 0;
6347         }
6348     }
6349
6350   if (h->got.offset != (bfd_vma) - 1
6351       && hent->tls_type == GOT_NORMAL)
6352     {
6353       asection *sgot;
6354       asection *srelagot;
6355       Elf_Internal_Rela rela;
6356
6357       /* This symbol has an entry in the global offset table.
6358          Set it up.  */
6359
6360       sgot = ehtab->sgot;
6361       srelagot = ehtab->srelgot;
6362       BFD_ASSERT (sgot != NULL && srelagot != NULL);
6363
6364       rela.r_offset = (sgot->output_section->vma
6365                        + sgot->output_offset + (h->got.offset & ~1));
6366
6367       /* If this is a -Bsymbolic link, and the symbol is defined
6368          locally, we just want to emit a RELATIVE reloc.  Likewise if
6369          the symbol was forced to be local because of a version file.
6370          The entry in the global offset table will already have been
6371          initialized in the relocate_section function.  */
6372       if ((bfd_link_pic (info)
6373            && (info->symbolic || h->dynindx == -1 || h->forced_local)
6374            && h->def_regular)
6375           || (bfd_link_pie (info) && h->def_regular))
6376         {
6377           rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
6378           rela.r_addend = (h->root.u.def.value
6379                            + h->root.u.def.section->output_section->vma
6380                            + h->root.u.def.section->output_offset);
6381
6382           if ((h->got.offset & 1) == 0)
6383             {
6384               bfd_put_32 (output_bfd, rela.r_addend,
6385                           sgot->contents + h->got.offset);
6386             }
6387         }
6388       else
6389         {
6390           BFD_ASSERT ((h->got.offset & 1) == 0);
6391           bfd_put_32 (output_bfd, (bfd_vma) 0,
6392                       sgot->contents + h->got.offset);
6393           rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
6394           rela.r_addend = 0;
6395         }
6396
6397       loc = srelagot->contents;
6398       loc += srelagot->reloc_count * sizeof (Elf32_External_Rela);
6399       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6400       ++srelagot->reloc_count;
6401       BFD_ASSERT (loc < (srelagot->contents + srelagot->size));
6402     }
6403
6404   if (h->needs_copy)
6405     {
6406       asection *s;
6407       Elf_Internal_Rela rela;
6408
6409       /* This symbols needs a copy reloc.  Set it up.  */
6410
6411       BFD_ASSERT (h->dynindx != -1
6412                   && (h->root.type == bfd_link_hash_defined
6413                       || h->root.type == bfd_link_hash_defweak));
6414
6415       s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
6416       BFD_ASSERT (s != NULL);
6417
6418       rela.r_offset = (h->root.u.def.value
6419                        + h->root.u.def.section->output_section->vma
6420                        + h->root.u.def.section->output_offset);
6421       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
6422       rela.r_addend = 0;
6423       loc = s->contents;
6424       loc += s->reloc_count * sizeof (Elf32_External_Rela);
6425       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6426       ++s->reloc_count;
6427     }
6428
6429   /* Mark some specially defined symbols as absolute.  */
6430   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6431       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6432     sym->st_shndx = SHN_ABS;
6433
6434   return TRUE;
6435 }
6436
6437
6438 /* Finish up the dynamic sections.  */
6439
6440 static bfd_boolean
6441 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6442 {
6443   bfd *dynobj;
6444   asection *sdyn;
6445   asection *sgotplt;
6446   struct elf_link_hash_table *ehtab;
6447   struct elf_nds32_link_hash_table *htab;
6448
6449   ehtab = elf_hash_table (info);
6450   htab = nds32_elf_hash_table (info);
6451   if (htab == NULL)
6452     return FALSE;
6453
6454   dynobj = elf_hash_table (info)->dynobj;
6455
6456   sgotplt = ehtab->sgotplt;
6457   /* A broken linker script might have discarded the dynamic sections.
6458      Catch this here so that we do not seg-fault later on.  */
6459   if (sgotplt != NULL && bfd_is_abs_section (sgotplt->output_section))
6460     return FALSE;
6461   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6462
6463   if (elf_hash_table (info)->dynamic_sections_created)
6464     {
6465       asection *splt;
6466       Elf32_External_Dyn *dyncon, *dynconend;
6467
6468       BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6469
6470       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6471       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6472
6473       for (; dyncon < dynconend; dyncon++)
6474         {
6475           Elf_Internal_Dyn dyn;
6476           asection *s;
6477
6478           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6479
6480           switch (dyn.d_tag)
6481             {
6482             default:
6483               break;
6484
6485             case DT_PLTGOT:
6486               /* name = ".got";  */
6487               s = ehtab->sgot->output_section;
6488               goto get_vma;
6489             case DT_JMPREL:
6490               s = ehtab->srelplt->output_section;
6491             get_vma:
6492               BFD_ASSERT (s != NULL);
6493               dyn.d_un.d_ptr = s->vma;
6494               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6495               break;
6496
6497             case DT_PLTRELSZ:
6498               s = ehtab->srelplt->output_section;
6499               BFD_ASSERT (s != NULL);
6500               dyn.d_un.d_val = s->size;
6501               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6502               break;
6503
6504             case DT_RELASZ:
6505               /* My reading of the SVR4 ABI indicates that the
6506                  procedure linkage table relocs (DT_JMPREL) should be
6507                  included in the overall relocs (DT_RELA).  This is
6508                  what Solaris does.  However, UnixWare can not handle
6509                  that case.  Therefore, we override the DT_RELASZ entry
6510                  here to make it not include the JMPREL relocs.  Since
6511                  the linker script arranges for .rela.plt to follow all
6512                  other relocation sections, we don't have to worry
6513                  about changing the DT_RELA entry.  */
6514               if (ehtab->srelplt != NULL)
6515                 {
6516                   s = ehtab->srelplt->output_section;
6517                   dyn.d_un.d_val -= s->size;
6518                 }
6519               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6520               break;
6521
6522             case DT_TLSDESC_PLT:
6523               s = htab->root.splt;
6524               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6525                                 + htab->dt_tlsdesc_plt);
6526               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6527               break;
6528
6529             case DT_TLSDESC_GOT:
6530               s = htab->root.sgot;
6531               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6532                                 + htab->dt_tlsdesc_got);
6533               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6534               break;
6535             }
6536         }
6537
6538       /* Fill in the first entry in the procedure linkage table.  */
6539       splt = ehtab->splt;
6540       if (splt && splt->size > 0)
6541         {
6542           if (bfd_link_pic (info))
6543             {
6544               unsigned long insn;
6545               long offset;
6546
6547               offset = sgotplt->output_section->vma + sgotplt->output_offset + 4
6548                 - elf_gp (output_bfd);
6549               insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
6550               bfd_putb32 (insn, splt->contents);
6551
6552               /* here has a typo?  */
6553               insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
6554               bfd_putb32 (insn, splt->contents + 4);
6555
6556               insn = PLT0_PIC_ENTRY_WORD2;
6557               bfd_putb32 (insn, splt->contents + 8);
6558
6559               insn = PLT0_PIC_ENTRY_WORD3;
6560               bfd_putb32 (insn, splt->contents + 12);
6561
6562               insn = PLT0_PIC_ENTRY_WORD4;
6563               bfd_putb32 (insn, splt->contents + 16);
6564
6565               insn = PLT0_PIC_ENTRY_WORD5;
6566               bfd_putb32 (insn, splt->contents + 20);
6567             }
6568           else
6569             {
6570               unsigned long insn;
6571               unsigned long addr;
6572
6573               /* addr = .got + 4 */
6574               addr = sgotplt->output_section->vma + sgotplt->output_offset + 4;
6575               insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
6576               bfd_putb32 (insn, splt->contents);
6577
6578               insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
6579               bfd_putb32 (insn, splt->contents + 4);
6580
6581               insn = PLT0_ENTRY_WORD2;
6582               bfd_putb32 (insn, splt->contents + 8);
6583
6584               insn = PLT0_ENTRY_WORD3;
6585               bfd_putb32 (insn, splt->contents + 12);
6586
6587               insn = PLT0_ENTRY_WORD4;
6588               bfd_putb32 (insn, splt->contents + 16);
6589             }
6590
6591           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
6592             PLT_ENTRY_SIZE;
6593         }
6594
6595       if (htab->dt_tlsdesc_plt)
6596         {
6597           /* Calculate addresses.  */
6598           asection *sgot = sgot = ehtab->sgot;
6599           bfd_vma pltgot = sgotplt->output_section->vma
6600             + sgotplt->output_offset;
6601           bfd_vma tlsdesc_got = sgot->output_section->vma + sgot->output_offset
6602             + htab->dt_tlsdesc_got;
6603
6604           /* Get GP offset.  */
6605           pltgot -= elf_gp (output_bfd) - 4; /* PLTGOT[1]  */
6606           tlsdesc_got -= elf_gp (output_bfd);
6607
6608           /* Do relocation.  */
6609           dl_tlsdesc_lazy_trampoline[0] += ((1 << 20) - 1) & (tlsdesc_got >> 12);
6610           dl_tlsdesc_lazy_trampoline[1] += 0xfff & tlsdesc_got;
6611           dl_tlsdesc_lazy_trampoline[4] += ((1 << 20) - 1) & (pltgot >> 12);
6612           dl_tlsdesc_lazy_trampoline[5] +=  0xfff & pltgot;
6613
6614           /* Insert .plt.  */
6615           nds32_put_trampoline (splt->contents + htab->dt_tlsdesc_plt,
6616                                 dl_tlsdesc_lazy_trampoline,
6617                                 ARRAY_SIZE (dl_tlsdesc_lazy_trampoline));
6618         }
6619     }
6620
6621   /* Fill in the first three entries in the global offset table.  */
6622   if (sgotplt && sgotplt->size > 0)
6623     {
6624       if (sdyn == NULL)
6625         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6626       else
6627         bfd_put_32 (output_bfd,
6628                     sdyn->output_section->vma + sdyn->output_offset,
6629                     sgotplt->contents);
6630       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6631       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6632
6633       elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6634     }
6635
6636   return TRUE;
6637 }
6638 \f
6639
6640 /* Set the right machine number.  */
6641
6642 static bfd_boolean
6643 nds32_elf_object_p (bfd *abfd)
6644 {
6645   static unsigned int cur_arch = 0;
6646
6647   if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
6648     {
6649       /* E_N1_ARCH is a wild card, so it is set only when no others exist.  */
6650       cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
6651     }
6652
6653   switch (cur_arch)
6654     {
6655     default:
6656     case E_N1_ARCH:
6657       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
6658       break;
6659     case E_N1H_ARCH:
6660       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
6661       break;
6662     case E_NDS_ARCH_STAR_V2_0:
6663       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
6664       break;
6665     case E_NDS_ARCH_STAR_V3_0:
6666       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
6667       break;
6668     case E_NDS_ARCH_STAR_V3_M:
6669       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
6670       break;
6671     }
6672
6673   return TRUE;
6674 }
6675
6676 /* Store the machine number in the flags field.  */
6677
6678 static bfd_boolean
6679 nds32_elf_final_write_processing (bfd *abfd)
6680 {
6681   unsigned long val;
6682   static unsigned int cur_mach = 0;
6683
6684   if (bfd_mach_n1 != bfd_get_mach (abfd))
6685     {
6686       cur_mach = bfd_get_mach (abfd);
6687     }
6688
6689   switch (cur_mach)
6690     {
6691     case bfd_mach_n1:
6692       /* Only happen when object is empty, since the case is abandon.  */
6693       val = E_N1_ARCH;
6694       val |= E_NDS_ABI_AABI;
6695       val |= E_NDS32_ELF_VER_1_4;
6696       break;
6697     case bfd_mach_n1h:
6698       val = E_N1H_ARCH;
6699       break;
6700     case bfd_mach_n1h_v2:
6701       val = E_NDS_ARCH_STAR_V2_0;
6702       break;
6703     case bfd_mach_n1h_v3:
6704       val = E_NDS_ARCH_STAR_V3_0;
6705       break;
6706     case bfd_mach_n1h_v3m:
6707       val = E_NDS_ARCH_STAR_V3_M;
6708       break;
6709     default:
6710       val = 0;
6711       break;
6712     }
6713
6714   elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
6715   elf_elfheader (abfd)->e_flags |= val;
6716   return _bfd_elf_final_write_processing (abfd);
6717 }
6718
6719 /* Function to keep NDS32 specific file flags.  */
6720
6721 static bfd_boolean
6722 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
6723 {
6724   BFD_ASSERT (!elf_flags_init (abfd)
6725               || elf_elfheader (abfd)->e_flags == flags);
6726
6727   elf_elfheader (abfd)->e_flags = flags;
6728   elf_flags_init (abfd) = TRUE;
6729   return TRUE;
6730 }
6731
6732 static unsigned int
6733 convert_e_flags (unsigned int e_flags, unsigned int arch)
6734 {
6735   if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
6736     {
6737       /* From 0.9 to 1.0.  */
6738       e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
6739
6740       /* Invert E_NDS32_HAS_NO_MAC_INST.  */
6741       e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6742       if (arch == E_NDS_ARCH_STAR_V1_0)
6743         {
6744           /* Done.  */
6745           return e_flags;
6746         }
6747     }
6748
6749   /* From 1.0 to 2.0.  */
6750   e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
6751
6752   /* Clear E_NDS32_HAS_MFUSR_PC_INST.  */
6753   e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
6754
6755   /* Invert E_NDS32_HAS_NO_MAC_INST.  */
6756   e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6757   return e_flags;
6758 }
6759
6760 static bfd_boolean
6761 nds32_check_vec_size (bfd *ibfd)
6762 {
6763   static unsigned int nds32_vec_size = 0;
6764
6765   asection *sec_t = NULL;
6766   bfd_byte *contents = NULL;
6767
6768   sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
6769
6770   if (sec_t && sec_t->size >= 4)
6771     {
6772       /* Get vec_size in file.  */
6773       unsigned int flag_t;
6774
6775       nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
6776       flag_t = bfd_get_32 (ibfd, contents);
6777
6778       /* The value could only be 4 or 16.  */
6779
6780       if (!nds32_vec_size)
6781         /* Set if not set yet.  */
6782         nds32_vec_size = (flag_t & 0x3);
6783       else if (nds32_vec_size != (flag_t & 0x3))
6784         {
6785           _bfd_error_handler
6786             /* xgettext:c-format */
6787             (_("%pB: ISR vector size mismatch"
6788                " with previous modules, previous %u-byte, current %u-byte"),
6789              ibfd,
6790              nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
6791              (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
6792           return FALSE;
6793         }
6794       else
6795         /* Only keep the first vec_size section.  */
6796         sec_t->flags |= SEC_EXCLUDE;
6797     }
6798
6799   return TRUE;
6800 }
6801
6802 /* Merge backend specific data from an object file to the output
6803    object file when linking.  */
6804
6805 static bfd_boolean
6806 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6807 {
6808   bfd *obfd = info->output_bfd;
6809   flagword out_flags;
6810   flagword in_flags;
6811   flagword out_16regs;
6812   flagword in_no_mac;
6813   flagword out_no_mac;
6814   flagword in_16regs;
6815   flagword out_version;
6816   flagword in_version;
6817   flagword out_fpu_config;
6818   flagword in_fpu_config;
6819
6820   /* FIXME: What should be checked when linking shared libraries?  */
6821   if ((ibfd->flags & DYNAMIC) != 0)
6822     return TRUE;
6823
6824   /* TODO: Revise to use object-attributes instead.  */
6825   if (!nds32_check_vec_size (ibfd))
6826     return FALSE;
6827
6828   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6829       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6830     return TRUE;
6831
6832   if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6833     {
6834       _bfd_error_handler
6835         (_("%pB: warning: endian mismatch with previous modules"), ibfd);
6836
6837       bfd_set_error (bfd_error_bad_value);
6838       return FALSE;
6839     }
6840
6841   /* -B option in objcopy cannot work as expected. e_flags = 0 shall be
6842      treat as generic one without checking and merging.  */
6843   if (elf_elfheader (ibfd)->e_flags)
6844     {
6845       in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6846       if (in_version == E_NDS32_ELF_VER_1_2)
6847         {
6848           _bfd_error_handler
6849             (_("%pB: warning: older version of object file encountered, "
6850                "please recompile with current tool chain"), ibfd);
6851         }
6852
6853       /* We may need to merge V1 and V2 arch object files to V2.  */
6854       if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6855           != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6856         {
6857           /* Need to convert version.  */
6858           if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6859               == E_NDS_ARCH_STAR_RESERVED)
6860             {
6861               elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6862             }
6863           else if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6864                    == E_NDS_ARCH_STAR_V3_M
6865                    && (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6866                    == E_NDS_ARCH_STAR_V3_0)
6867             {
6868               elf_elfheader (ibfd)->e_flags =
6869                 (elf_elfheader (ibfd)->e_flags & (~EF_NDS_ARCH))
6870                 | E_NDS_ARCH_STAR_V3_0;
6871             }
6872           else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6873                    == E_NDS_ARCH_STAR_V0_9
6874                    || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6875                    > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6876             {
6877               elf_elfheader (obfd)->e_flags =
6878                 convert_e_flags (elf_elfheader (obfd)->e_flags,
6879                                  (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6880             }
6881           else
6882             {
6883               elf_elfheader (ibfd)->e_flags =
6884                 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6885                                  (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6886             }
6887         }
6888
6889       /* Extract some flags.  */
6890       in_flags = elf_elfheader (ibfd)->e_flags
6891         & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6892              | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6893
6894       /* The following flags need special treatment.  */
6895       in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6896       in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6897       in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6898
6899       /* Extract some flags.  */
6900       out_flags = elf_elfheader (obfd)->e_flags
6901         & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6902              | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6903
6904       /* The following flags need special treatment.  */
6905       out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6906       out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6907       out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6908       out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6909       if (!elf_flags_init (obfd))
6910         {
6911           /* If the input is the default architecture then do not
6912              bother setting the flags for the output architecture,
6913              instead allow future merges to do this.  If no future
6914              merges ever set these flags then they will retain their
6915              unitialised values, which surprise surprise, correspond
6916              to the default values.  */
6917           if (bfd_get_arch_info (ibfd)->the_default)
6918             return TRUE;
6919
6920           elf_flags_init (obfd) = TRUE;
6921           elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6922
6923           if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6924               && bfd_get_arch_info (obfd)->the_default)
6925             {
6926               return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6927                                         bfd_get_mach (ibfd));
6928             }
6929
6930           return TRUE;
6931         }
6932
6933       /* Check flag compatibility.  */
6934       if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6935         {
6936           _bfd_error_handler
6937             (_("%pB: error: ABI mismatch with previous modules"), ibfd);
6938           bfd_set_error (bfd_error_bad_value);
6939           return FALSE;
6940         }
6941
6942       if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6943         {
6944           if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6945             {
6946               _bfd_error_handler
6947                 (_("%pB: error: instruction set mismatch with previous modules"),
6948                  ibfd);
6949
6950               bfd_set_error (bfd_error_bad_value);
6951               return FALSE;
6952             }
6953         }
6954
6955       /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6956          and perf ext1 and DIV are mergerd to perf ext1.  */
6957       if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6958         {
6959           elf_elfheader (obfd)->e_flags =
6960             (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6961             | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6962             | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6963                ?  E_NDS32_HAS_EXT_INST : 0)
6964             | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6965                ?  E_NDS32_HAS_EXT_INST : 0)
6966             | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6967             | ((in_version > out_version) ? out_version : in_version);
6968         }
6969       else
6970         {
6971           if (in_version != out_version)
6972             _bfd_error_handler
6973               /* xgettext:c-format */
6974               (_("%pB: warning: incompatible elf-versions %s and %s"),
6975                ibfd, nds32_elfver_strtab[out_version],
6976                nds32_elfver_strtab[in_version]);
6977
6978           elf_elfheader (obfd)->e_flags = in_flags | out_flags
6979             | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6980             | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6981             | (in_version > out_version ?  out_version : in_version);
6982         }
6983     }
6984
6985   return TRUE;
6986 }
6987
6988 /* Display the flags field.  */
6989
6990 static bfd_boolean
6991 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6992 {
6993   FILE *file = (FILE *) ptr;
6994
6995   BFD_ASSERT (abfd != NULL && ptr != NULL);
6996
6997   _bfd_elf_print_private_bfd_data (abfd, ptr);
6998
6999   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
7000
7001   switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
7002     {
7003     default:
7004     case E_N1_ARCH:
7005       fprintf (file, _(": n1 instructions"));
7006       break;
7007     case E_N1H_ARCH:
7008       fprintf (file, _(": n1h instructions"));
7009       break;
7010     }
7011
7012   fputc ('\n', file);
7013
7014   return TRUE;
7015 }
7016
7017 static unsigned int
7018 nds32_elf_action_discarded (asection *sec)
7019 {
7020
7021   if (strncmp
7022       (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
7023     return 0;
7024
7025   return _bfd_elf_default_action_discarded (sec);
7026 }
7027
7028 static asection *
7029 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
7030                         Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
7031                         Elf_Internal_Sym *sym)
7032 {
7033   if (h != NULL)
7034     switch (ELF32_R_TYPE (rel->r_info))
7035       {
7036       case R_NDS32_GNU_VTINHERIT:
7037       case R_NDS32_GNU_VTENTRY:
7038       case R_NDS32_RELA_GNU_VTINHERIT:
7039       case R_NDS32_RELA_GNU_VTENTRY:
7040         return NULL;
7041       }
7042
7043   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
7044 }
7045
7046 static enum elf_nds32_tls_type
7047 get_tls_type (enum elf_nds32_reloc_type r_type,
7048               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7049 {
7050   enum elf_nds32_tls_type tls_type;
7051
7052   switch (r_type)
7053     {
7054     case R_NDS32_TLS_LE_HI20:
7055     case R_NDS32_TLS_LE_LO12:
7056       tls_type = GOT_TLS_LE;
7057       break;
7058     case R_NDS32_TLS_IE_HI20:
7059     case R_NDS32_TLS_IE_LO12S2:
7060     case R_NDS32_TLS_IE_LO12:
7061       tls_type = GOT_TLS_IE;
7062       break;
7063     case R_NDS32_TLS_IEGP_HI20:
7064     case R_NDS32_TLS_IEGP_LO12:
7065     case R_NDS32_TLS_IEGP_LO12S2:
7066       tls_type = GOT_TLS_IEGP;
7067       break;
7068     case R_NDS32_TLS_DESC_HI20:
7069     case R_NDS32_TLS_DESC_LO12:
7070     case R_NDS32_TLS_DESC_ADD:
7071     case R_NDS32_TLS_DESC_FUNC:
7072     case R_NDS32_TLS_DESC_CALL:
7073       tls_type = GOT_TLS_DESC;
7074       break;
7075     default:
7076       tls_type = GOT_NORMAL;
7077       break;
7078     }
7079
7080   return tls_type;
7081 }
7082
7083 /* Ensure that we have allocated bookkeeping structures for ABFD's local
7084    symbols.  */
7085
7086 static bfd_boolean
7087 elf32_nds32_allocate_local_sym_info (bfd *abfd)
7088 {
7089   if (elf_local_got_refcounts (abfd) == NULL)
7090     {
7091       bfd_size_type num_syms;
7092       bfd_size_type size;
7093       char *data;
7094
7095       num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
7096       /* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
7097          gp_offset.  The details can refer to struct elf_nds32_obj_tdata.  */
7098       size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
7099                          + sizeof (bfd_vma) + sizeof (int)
7100                          + sizeof (bfd_boolean) + sizeof (bfd_vma));
7101       data = bfd_zalloc (abfd, size);
7102       if (data == NULL)
7103         return FALSE;
7104
7105       elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
7106       data += num_syms * sizeof (bfd_signed_vma);
7107
7108       elf32_nds32_local_got_tls_type (abfd) = (char *) data;
7109       data += num_syms * sizeof (char);
7110
7111       elf32_nds32_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
7112       data += num_syms * sizeof (bfd_vma);
7113
7114       elf32_nds32_local_gp_offset (abfd) = (int *) data;
7115       data += num_syms * sizeof (int);
7116     }
7117
7118   return TRUE;
7119 }
7120
7121 /* Look through the relocs for a section during the first phase.
7122    Since we don't do .gots or .plts, we just need to consider the
7123    virtual table relocs for gc.  */
7124
7125 static bfd_boolean
7126 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7127                         asection *sec, const Elf_Internal_Rela *relocs)
7128 {
7129   Elf_Internal_Shdr *symtab_hdr;
7130   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
7131   const Elf_Internal_Rela *rel;
7132   const Elf_Internal_Rela *rel_end;
7133   struct elf_link_hash_table *ehtab;
7134   struct elf_nds32_link_hash_table *htab;
7135   bfd *dynobj;
7136   asection *sreloc = NULL;
7137
7138   /* No need for relocation if relocatable already.  */
7139   if (bfd_link_relocatable (info))
7140     {
7141       elf32_nds32_check_relax_group (abfd, sec);
7142       return TRUE;
7143     }
7144
7145   /* Don't do anything special with non-loaded, non-alloced sections.
7146      In particular, any relocs in such sections should not affect GOT
7147      and PLT reference counting (ie. we don't allow them to create GOT
7148      or PLT entries), there's no possibility or desire to optimize TLS
7149      relocs, and there's not much point in propagating relocs to shared
7150      libs that the dynamic linker won't relocate.  */
7151   if ((sec->flags & SEC_ALLOC) == 0)
7152     return TRUE;
7153
7154   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7155   sym_hashes = elf_sym_hashes (abfd);
7156   sym_hashes_end =
7157     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
7158   if (!elf_bad_symtab (abfd))
7159     sym_hashes_end -= symtab_hdr->sh_info;
7160
7161   ehtab = elf_hash_table (info);
7162   htab = nds32_elf_hash_table (info);
7163   dynobj = htab->root.dynobj;
7164
7165   rel_end = relocs + sec->reloc_count;
7166   for (rel = relocs; rel < rel_end; rel++)
7167     {
7168       enum elf_nds32_reloc_type r_type;
7169       struct elf_link_hash_entry *h;
7170       unsigned long r_symndx;
7171       enum elf_nds32_tls_type tls_type, old_tls_type;
7172
7173       r_symndx = ELF32_R_SYM (rel->r_info);
7174       r_type = ELF32_R_TYPE (rel->r_info);
7175       if (r_symndx < symtab_hdr->sh_info)
7176         h = NULL;
7177       else
7178         {
7179           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7180           while (h->root.type == bfd_link_hash_indirect
7181                  || h->root.type == bfd_link_hash_warning)
7182             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7183         }
7184
7185       /* Create .got section if necessary.
7186          Some relocs require a global offset table.  We create
7187          got section here, since these relocation need a got section
7188          and if it is not created yet.  */
7189       if (ehtab->sgot == NULL)
7190         {
7191           switch (r_type)
7192             {
7193             case R_NDS32_GOT_HI20:
7194             case R_NDS32_GOT_LO12:
7195             case R_NDS32_GOT_LO15:
7196             case R_NDS32_GOT_LO19:
7197             case R_NDS32_GOT17S2_RELA:
7198             case R_NDS32_GOT15S2_RELA:
7199             case R_NDS32_GOTOFF:
7200             case R_NDS32_GOTOFF_HI20:
7201             case R_NDS32_GOTOFF_LO12:
7202             case R_NDS32_GOTOFF_LO15:
7203             case R_NDS32_GOTOFF_LO19:
7204             case R_NDS32_GOTPC20:
7205             case R_NDS32_GOTPC_HI20:
7206             case R_NDS32_GOTPC_LO12:
7207             case R_NDS32_GOT20:
7208             case R_NDS32_TLS_IE_HI20:
7209             case R_NDS32_TLS_IE_LO12:
7210             case R_NDS32_TLS_IE_LO12S2:
7211             case R_NDS32_TLS_IEGP_HI20:
7212             case R_NDS32_TLS_IEGP_LO12:
7213             case R_NDS32_TLS_IEGP_LO12S2:
7214             case R_NDS32_TLS_DESC_HI20:
7215             case R_NDS32_TLS_DESC_LO12:
7216               if (dynobj == NULL)
7217                 htab->root.dynobj = dynobj = abfd;
7218               if (!create_got_section (dynobj, info))
7219                 return FALSE;
7220               break;
7221
7222             default:
7223               break;
7224             }
7225         }
7226
7227       /* Check relocation type.  */
7228       switch ((int) r_type)
7229         {
7230         case R_NDS32_GOT_HI20:
7231         case R_NDS32_GOT_LO12:
7232         case R_NDS32_GOT_LO15:
7233         case R_NDS32_GOT_LO19:
7234         case R_NDS32_GOT20:
7235         case R_NDS32_TLS_LE_HI20:
7236         case R_NDS32_TLS_LE_LO12:
7237         case R_NDS32_TLS_IE_HI20:
7238         case R_NDS32_TLS_IE_LO12:
7239         case R_NDS32_TLS_IE_LO12S2:
7240         case R_NDS32_TLS_IEGP_HI20:
7241         case R_NDS32_TLS_IEGP_LO12:
7242         case R_NDS32_TLS_IEGP_LO12S2:
7243         case R_NDS32_TLS_DESC_HI20:
7244         case R_NDS32_TLS_DESC_LO12:
7245           tls_type = get_tls_type (r_type, h);
7246           if (h)
7247             {
7248               if (tls_type != GOT_TLS_LE)
7249                 h->got.refcount += 1;
7250               old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
7251             }
7252           else
7253             {
7254               /* This is a global offset table entry for a local symbol.  */
7255               if (!elf32_nds32_allocate_local_sym_info (abfd))
7256                 return FALSE;
7257
7258               BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7259               if (tls_type != GOT_TLS_LE)
7260                 elf_local_got_refcounts (abfd)[r_symndx] += 1;
7261               old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
7262             }
7263
7264           /* We would already have issued an error message if there
7265              is a TLS/non-TLS mismatch, based on the symbol
7266              type.  So just combine any TLS types needed.  */
7267           if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7268               && tls_type != GOT_NORMAL)
7269             tls_type |= old_tls_type;
7270
7271           /* DESC to IE/IEGP if link to executable.  */
7272           if ((tls_type & (GOT_TLS_DESC | GOT_TLS_IEGP))
7273               && (bfd_link_executable (info)))
7274             tls_type |= (bfd_link_pie (info) ? GOT_TLS_IEGP : GOT_TLS_IE);
7275
7276           if (old_tls_type != tls_type)
7277             {
7278               if (h != NULL)
7279                 elf32_nds32_hash_entry (h)->tls_type = tls_type;
7280               else
7281                 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
7282             }
7283           break;
7284         case R_NDS32_9_PLTREL:
7285         case R_NDS32_25_PLTREL:
7286         case R_NDS32_PLTREL_HI20:
7287         case R_NDS32_PLTREL_LO12:
7288         case R_NDS32_PLT_GOTREL_HI20:
7289         case R_NDS32_PLT_GOTREL_LO12:
7290         case R_NDS32_PLT_GOTREL_LO15:
7291         case R_NDS32_PLT_GOTREL_LO19:
7292         case R_NDS32_PLT_GOTREL_LO20:
7293
7294           /* This symbol requires a procedure linkage table entry.  We
7295              actually build the entry in adjust_dynamic_symbol,
7296              because this might be a case of linking PIC code without
7297              linking in any dynamic objects, in which case we don't
7298              need to generate a procedure linkage table after all.  */
7299
7300           /* If this is a local symbol, we resolve it directly without
7301              creating a procedure linkage table entry.  */
7302           if (h == NULL)
7303             continue;
7304
7305           if (h->forced_local
7306               || (bfd_link_pie (info) && h->def_regular))
7307             break;
7308
7309           elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
7310           h->needs_plt = 1;
7311           h->plt.refcount += 1;
7312           break;
7313
7314         case R_NDS32_16_RELA:
7315         case R_NDS32_20_RELA:
7316         case R_NDS32_5_RELA:
7317         case R_NDS32_32_RELA:
7318         case R_NDS32_HI20_RELA:
7319         case R_NDS32_LO12S3_RELA:
7320         case R_NDS32_LO12S2_RELA:
7321         case R_NDS32_LO12S2_DP_RELA:
7322         case R_NDS32_LO12S2_SP_RELA:
7323         case R_NDS32_LO12S1_RELA:
7324         case R_NDS32_LO12S0_RELA:
7325         case R_NDS32_LO12S0_ORI_RELA:
7326         case R_NDS32_SDA16S3_RELA:
7327         case R_NDS32_SDA17S2_RELA:
7328         case R_NDS32_SDA18S1_RELA:
7329         case R_NDS32_SDA19S0_RELA:
7330         case R_NDS32_SDA15S3_RELA:
7331         case R_NDS32_SDA15S2_RELA:
7332         case R_NDS32_SDA12S2_DP_RELA:
7333         case R_NDS32_SDA12S2_SP_RELA:
7334         case R_NDS32_SDA15S1_RELA:
7335         case R_NDS32_SDA15S0_RELA:
7336         case R_NDS32_SDA_FP7U2_RELA:
7337         case R_NDS32_15_PCREL_RELA:
7338         case R_NDS32_17_PCREL_RELA:
7339         case R_NDS32_25_PCREL_RELA:
7340
7341           if (h != NULL && !bfd_link_pic (info))
7342             {
7343               h->non_got_ref = 1;
7344               h->plt.refcount += 1;
7345             }
7346
7347           /* If we are creating a shared library, and this is a reloc against
7348              a global symbol, or a non PC relative reloc against a local
7349              symbol, then we need to copy the reloc into the shared library.
7350              However, if we are linking with -Bsymbolic, we do not need to
7351              copy a reloc against a global symbol which is defined in an
7352              object we are including in the link (i.e., DEF_REGULAR is set).
7353              At this point we have not seen all the input files, so it is
7354              possible that DEF_REGULAR is not set now but will be set later
7355              (it is never cleared).  We account for that possibility below by
7356              storing information in the dyn_relocs field of the hash table
7357              entry.  A similar situation occurs when creating shared libraries
7358              and symbol visibility changes render the symbol local.
7359
7360              If on the other hand, we are creating an executable, we may need
7361              to keep relocations for symbols satisfied by a dynamic library
7362              if we manage to avoid copy relocs for the symbol.  */
7363           if ((bfd_link_pic (info)
7364                && (sec->flags & SEC_ALLOC) != 0
7365                && ((r_type != R_NDS32_25_PCREL_RELA
7366                     && r_type != R_NDS32_15_PCREL_RELA
7367                     && r_type != R_NDS32_17_PCREL_RELA
7368                     && !(r_type == R_NDS32_32_RELA
7369                          && strcmp (sec->name, ".eh_frame") == 0))
7370                    || (h != NULL
7371                        && (!info->symbolic
7372                            || h->root.type == bfd_link_hash_defweak
7373                            || !h->def_regular))))
7374               || (!bfd_link_pic (info)
7375                   && (sec->flags & SEC_ALLOC) != 0
7376                   && h != NULL
7377                   && (h->root.type == bfd_link_hash_defweak
7378                       || !h->def_regular)))
7379             {
7380               struct elf_dyn_relocs *p;
7381               struct elf_dyn_relocs **head;
7382
7383               if (dynobj == NULL)
7384                 htab->root.dynobj = dynobj = abfd;
7385
7386               /* When creating a shared object, we must copy these
7387                  relocs into the output file.  We create a reloc
7388                  section in dynobj and make room for the reloc.  */
7389               if (sreloc == NULL)
7390                 {
7391                   const char *name;
7392
7393                   name = bfd_elf_string_from_elf_section
7394                     (abfd, elf_elfheader (abfd)->e_shstrndx,
7395                      elf_section_data (sec)->rela.hdr->sh_name);
7396                   if (name == NULL)
7397                     return FALSE;
7398
7399                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
7400                               && strcmp (bfd_section_name (sec),
7401                                          name + 5) == 0);
7402
7403                   sreloc = bfd_get_section_by_name (dynobj, name);
7404                   if (sreloc == NULL)
7405                     {
7406                       flagword flags;
7407
7408                       sreloc = bfd_make_section (dynobj, name);
7409                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
7410                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7411                       if ((sec->flags & SEC_ALLOC) != 0)
7412                         flags |= SEC_ALLOC | SEC_LOAD;
7413                       if (sreloc == NULL
7414                           || !bfd_set_section_flags (sreloc, flags)
7415                           || !bfd_set_section_alignment (sreloc, 2))
7416                         return FALSE;
7417
7418                       elf_section_type (sreloc) = SHT_RELA;
7419                     }
7420                   elf_section_data (sec)->sreloc = sreloc;
7421                 }
7422
7423               /* If this is a global symbol, we count the number of
7424                  relocations we need for this symbol.  */
7425               if (h != NULL)
7426                 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
7427               else
7428                 {
7429                   asection *s;
7430                   void *vpp;
7431
7432                   Elf_Internal_Sym *isym;
7433                   isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
7434                   if (isym == NULL)
7435                     return FALSE;
7436
7437                   /* Track dynamic relocs needed for local syms too.  */
7438                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7439                   if (s == NULL)
7440                     return FALSE;
7441
7442                   vpp = &elf_section_data (s)->local_dynrel;
7443                   head = (struct elf_dyn_relocs **) vpp;
7444                 }
7445
7446               p = *head;
7447               if (p == NULL || p->sec != sec)
7448                 {
7449                   size_t amt = sizeof (*p);
7450                   p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
7451                   if (p == NULL)
7452                     return FALSE;
7453                   p->next = *head;
7454                   *head = p;
7455                   p->sec = sec;
7456                   p->count = 0;
7457                   p->pc_count = 0;
7458                 }
7459
7460               p->count += 1;
7461
7462               /* Since eh_frame is readonly, R_NDS32_32_RELA
7463                  reloc for eh_frame will cause shared library has
7464                  TEXTREL entry in the dynamic section. This lead glibc
7465                  testsuites to failure (bug-13092) and cause kernel fail
7466                  (bug-11819).  I think the best solution is to replace
7467                  absolute reloc with pc relative reloc in the eh_frame.
7468                  To do that, we need to support the following issues:
7469
7470                  === For GCC ===
7471                  * gcc/config/nds32/nds32.h: Define
7472                  ASM_PREFERRED_EH_DATA_FORMAT to encode DW_EH_PE_pcrel
7473                  and DW_EH_PE_sdata4 into DWARF exception header when
7474                  option have '-fpic'.
7475
7476                  === For binutils ===
7477                  * bfd/: Define new reloc R_NDS32_32_PCREL_RELA.
7478                  * gas/config/tc-nds32.h: Define DIFF_EXPR_OK. This
7479                  may break our nds DIFF mechanism, therefore, we
7480                  must disable all linker relaxations to ensure
7481                  correctness.
7482                  * gas/config/tc-nds32.c (nds32_apply_fix): Replace
7483                  R_NDS32_32_RELA with R_NDS32_32_PCREL_RELA, and
7484                  do the necessary modification.
7485
7486                  Unfortunately, it still have some problems for nds32
7487                  to support pc relative reloc in the eh_frame. So I use
7488                  another solution to fix this issue.
7489
7490                  However, I find that ld always emit TEXTREL marker for
7491                  R_NDS32_NONE relocs in rel.dyn. These none relocs are
7492                  correspond to R_NDS32_32_RELA for .eh_frame section.
7493                  It means that we always reserve redundant entries of rel.dyn
7494                  for these relocs which actually do nothing in dynamic linker.
7495
7496                  Therefore, we regard these relocs as pc relative relocs
7497                  here and increase the pc_count.  */
7498               if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
7499                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
7500                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
7501                   || (r_type == R_NDS32_32_RELA
7502                       && strcmp (sec->name, ".eh_frame") == 0))
7503                 p->pc_count += 1;
7504             }
7505           break;
7506
7507           /* This relocation describes the C++ object vtable hierarchy.
7508              Reconstruct it for later use during GC.  */
7509         case R_NDS32_RELA_GNU_VTINHERIT:
7510         case R_NDS32_GNU_VTINHERIT:
7511           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7512             return FALSE;
7513           break;
7514
7515           /* This relocation describes which C++ vtable entries are actually
7516              used.  Record for later use during GC.  */
7517         case R_NDS32_GNU_VTENTRY:
7518           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7519             return FALSE;
7520           break;
7521         case R_NDS32_RELA_GNU_VTENTRY:
7522           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
7523             return FALSE;
7524           break;
7525         }
7526     }
7527
7528   return TRUE;
7529 }
7530
7531 /* Write VAL in uleb128 format to P, returning a pointer to the
7532    following byte.
7533    This code is copied from elf-attr.c.  */
7534
7535 static bfd_byte *
7536 write_uleb128 (bfd_byte *p, unsigned int val)
7537 {
7538   bfd_byte c;
7539   do
7540     {
7541       c = val & 0x7f;
7542       val >>= 7;
7543       if (val)
7544         c |= 0x80;
7545       *(p++) = c;
7546     }
7547   while (val);
7548   return p;
7549 }
7550
7551 static bfd_signed_vma
7552 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
7553                   Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
7554 {
7555   bfd_signed_vma foff;
7556   bfd_vma symval, addend;
7557   asection *sym_sec;
7558
7559   /* Get the value of the symbol referred to by the reloc.  */
7560   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7561     {
7562       Elf_Internal_Sym *isym;
7563
7564       /* A local symbol.  */
7565       isym = isymbuf + ELF32_R_SYM (irel->r_info);
7566
7567       if (isym->st_shndx == SHN_UNDEF)
7568         sym_sec = bfd_und_section_ptr;
7569       else if (isym->st_shndx == SHN_ABS)
7570         sym_sec = bfd_abs_section_ptr;
7571       else if (isym->st_shndx == SHN_COMMON)
7572         sym_sec = bfd_com_section_ptr;
7573       else
7574         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7575       symval = isym->st_value + sym_sec->output_section->vma
7576                + sym_sec->output_offset;
7577     }
7578   else
7579     {
7580       unsigned long indx;
7581       struct elf_link_hash_entry *h;
7582
7583       /* An external symbol.  */
7584       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7585       h = elf_sym_hashes (abfd)[indx];
7586       BFD_ASSERT (h != NULL);
7587
7588       if (h->root.type != bfd_link_hash_defined
7589           && h->root.type != bfd_link_hash_defweak)
7590         /* This appears to be a reference to an undefined
7591            symbol.  Just ignore it--it will be caught by the
7592            regular reloc processing.  */
7593         return 0;
7594
7595       if (h->root.u.def.section->flags & SEC_MERGE)
7596         {
7597           sym_sec = h->root.u.def.section;
7598           symval = _bfd_merged_section_offset (abfd, &sym_sec,
7599                                                elf_section_data (sym_sec)->sec_info,
7600                                                h->root.u.def.value);
7601           symval = symval + sym_sec->output_section->vma
7602                    + sym_sec->output_offset;
7603         }
7604       else
7605         symval = (h->root.u.def.value
7606                   + h->root.u.def.section->output_section->vma
7607                   + h->root.u.def.section->output_offset);
7608     }
7609
7610   addend = irel->r_addend;
7611
7612   foff = (symval + addend
7613           - (irel->r_offset + sec->output_section->vma + sec->output_offset));
7614   return foff;
7615 }
7616 \f
7617
7618 /* Convert a 32-bit instruction to 16-bit one.
7619    INSN is the input 32-bit instruction, INSN16 is the output 16-bit
7620    instruction.  If INSN_TYPE is not NULL, it the CGEN instruction
7621    type of INSN16.  Return 1 if successful.  */
7622
7623 static int
7624 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7625                              int *pinsn_type)
7626 {
7627   uint16_t insn16 = 0;
7628   int insn_type = 0;
7629   unsigned long mach = bfd_get_mach (abfd);
7630
7631   if (N32_SH5 (insn) != 0)
7632     return 0;
7633
7634   switch (N32_SUB5 (insn))
7635     {
7636     case N32_ALU1_ADD_SLLI:
7637     case N32_ALU1_ADD_SRLI:
7638       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7639         {
7640           insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
7641                                 N32_RB5 (insn));
7642           insn_type = NDS32_INSN_ADD333;
7643         }
7644       else if (N32_IS_RT4 (insn))
7645         {
7646           if (N32_RT5 (insn) == N32_RA5 (insn))
7647             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
7648           else if (N32_RT5 (insn) == N32_RB5 (insn))
7649             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
7650           insn_type = NDS32_INSN_ADD45;
7651         }
7652       break;
7653
7654     case N32_ALU1_SUB_SLLI:
7655     case N32_ALU1_SUB_SRLI:
7656       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7657         {
7658           insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
7659                                 N32_RB5 (insn));
7660           insn_type = NDS32_INSN_SUB333;
7661         }
7662       else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7663         {
7664           insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
7665           insn_type = NDS32_INSN_SUB45;
7666         }
7667       break;
7668
7669     case N32_ALU1_AND_SLLI:
7670     case N32_ALU1_AND_SRLI:
7671       /* and $rt, $rt, $rb -> and33 for v3, v3m.  */
7672       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7673           && N32_IS_RB3 (insn))
7674         {
7675           if (N32_RT5 (insn) == N32_RA5 (insn))
7676             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
7677           else if (N32_RT5 (insn) == N32_RB5 (insn))
7678             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
7679           if (insn16)
7680             insn_type = NDS32_INSN_AND33;
7681         }
7682       break;
7683
7684     case N32_ALU1_XOR_SLLI:
7685     case N32_ALU1_XOR_SRLI:
7686       /* xor $rt, $rt, $rb -> xor33 for v3, v3m.  */
7687       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7688           && N32_IS_RB3 (insn))
7689         {
7690           if (N32_RT5 (insn) == N32_RA5 (insn))
7691             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
7692           else if (N32_RT5 (insn) == N32_RB5 (insn))
7693             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
7694           if (insn16)
7695             insn_type = NDS32_INSN_XOR33;
7696         }
7697       break;
7698
7699     case N32_ALU1_OR_SLLI:
7700     case N32_ALU1_OR_SRLI:
7701       /* or $rt, $rt, $rb -> or33 for v3, v3m.  */
7702       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7703           && N32_IS_RB3 (insn))
7704         {
7705           if (N32_RT5 (insn) == N32_RA5 (insn))
7706             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
7707           else if (N32_RT5 (insn) == N32_RB5 (insn))
7708             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
7709           if (insn16)
7710             insn_type = NDS32_INSN_OR33;
7711         }
7712       break;
7713     case N32_ALU1_NOR:
7714       /* nor $rt, $ra, $ra -> not33 for v3, v3m.  */
7715       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
7716           && N32_RA5 (insn) == N32_RB5 (insn))
7717         {
7718           insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
7719           insn_type = NDS32_INSN_NOT33;
7720         }
7721       break;
7722     case N32_ALU1_SRAI:
7723       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7724         {
7725           insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
7726           insn_type = NDS32_INSN_SRAI45;
7727         }
7728       break;
7729
7730     case N32_ALU1_SRLI:
7731       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7732         {
7733           insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
7734           insn_type = NDS32_INSN_SRLI45;
7735         }
7736       break;
7737
7738     case N32_ALU1_SLLI:
7739       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
7740         {
7741           insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
7742                                 N32_UB5 (insn));
7743           insn_type = NDS32_INSN_SLLI333;
7744         }
7745       break;
7746
7747     case N32_ALU1_ZEH:
7748       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7749         {
7750           insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
7751           insn_type = NDS32_INSN_ZEH33;
7752         }
7753       break;
7754
7755     case N32_ALU1_SEB:
7756       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7757         {
7758           insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7759           insn_type = NDS32_INSN_SEB33;
7760         }
7761       break;
7762
7763     case N32_ALU1_SEH:
7764       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7765         {
7766           insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7767           insn_type = NDS32_INSN_SEH33;
7768         }
7769       break;
7770
7771     case N32_ALU1_SLT:
7772       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7773         {
7774           /* Implicit r15.  */
7775           insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7776           insn_type = NDS32_INSN_SLT45;
7777         }
7778       break;
7779
7780     case N32_ALU1_SLTS:
7781       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7782         {
7783           /* Implicit r15.  */
7784           insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7785           insn_type = NDS32_INSN_SLTS45;
7786         }
7787       break;
7788     }
7789
7790   if ((insn16 & 0x8000) == 0)
7791     return 0;
7792
7793   if (pinsn16)
7794     *pinsn16 = insn16;
7795   if (pinsn_type)
7796     *pinsn_type = insn_type;
7797   return 1;
7798 }
7799
7800 static int
7801 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7802                              int *pinsn_type)
7803 {
7804   uint16_t insn16 = 0;
7805   int insn_type;
7806   unsigned long mach = bfd_get_mach (abfd);
7807
7808   /* TODO: bset, bclr, btgl, btst.  */
7809   if (__GF (insn, 6, 4) != 0)
7810     return 0;
7811
7812   switch (N32_IMMU (insn, 6))
7813     {
7814     case N32_ALU2_MUL:
7815       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7816           && N32_IS_RB3 (insn))
7817         {
7818           if (N32_RT5 (insn) == N32_RA5 (insn))
7819             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7820           else if (N32_RT5 (insn) == N32_RB5 (insn))
7821             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7822           if (insn16)
7823             insn_type = NDS32_INSN_MUL33;
7824         }
7825     }
7826
7827   if ((insn16 & 0x8000) == 0)
7828     return 0;
7829
7830   if (pinsn16)
7831     *pinsn16 = insn16;
7832   if (pinsn_type)
7833     *pinsn_type = insn_type;
7834   return 1;
7835 }
7836
7837 int
7838 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7839                         int *pinsn_type)
7840 {
7841   int op6;
7842   uint16_t insn16 = 0;
7843   int insn_type = 0;
7844   unsigned long mach = bfd_get_mach (abfd);
7845
7846   /* Decode 32-bit instruction.  */
7847   if (insn & 0x80000000)
7848     {
7849       /* Not 32-bit insn.  */
7850       return 0;
7851     }
7852
7853   op6 = N32_OP6 (insn);
7854
7855   /* Convert it to 16-bit instruction.  */
7856   switch (op6)
7857     {
7858     case N32_OP6_MOVI:
7859       if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7860         {
7861           insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7862           insn_type = NDS32_INSN_MOVI55;
7863         }
7864       else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7865                && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7866         {
7867           insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7868                                N32_IMM20S (insn) - 16);
7869           insn_type = NDS32_INSN_MOVPI45;
7870         }
7871       break;
7872
7873     case N32_OP6_ADDI:
7874       if (N32_IMM15S (insn) == 0)
7875         {
7876           /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7877              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7878           if (mach <= MACH_V2
7879               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7880             {
7881               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7882               insn_type = NDS32_INSN_MOV55;
7883             }
7884         }
7885       else if (N32_IMM15S (insn) > 0)
7886         {
7887           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7888             {
7889               insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7890                                     N32_IMM15S (insn));
7891               insn_type = NDS32_INSN_ADDI333;
7892             }
7893           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7894                    && N32_IMM15S (insn) < 32)
7895             {
7896               insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7897               insn_type = NDS32_INSN_ADDI45;
7898             }
7899           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7900                    && N32_RT5 (insn) == N32_RA5 (insn)
7901                    && N32_IMM15S (insn) < 512)
7902             {
7903               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7904               insn_type = NDS32_INSN_ADDI10_SP;
7905             }
7906           else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7907                    && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7908                    && (N32_IMM15S (insn) % 4 == 0))
7909             {
7910               insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7911                                    N32_IMM15S (insn) >> 2);
7912               insn_type = NDS32_INSN_ADDRI36_SP;
7913             }
7914         }
7915       else
7916         {
7917           /* Less than 0.  */
7918           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7919             {
7920               insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7921                                     0 - N32_IMM15S (insn));
7922               insn_type = NDS32_INSN_SUBI333;
7923             }
7924           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7925                    && N32_IMM15S (insn) > -32)
7926             {
7927               insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7928                                    0 - N32_IMM15S (insn));
7929               insn_type = NDS32_INSN_SUBI45;
7930             }
7931           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7932                    && N32_RT5 (insn) == N32_RA5 (insn)
7933                    && N32_IMM15S (insn) >= -512)
7934             {
7935               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7936               insn_type = NDS32_INSN_ADDI10_SP;
7937             }
7938         }
7939       break;
7940
7941     case N32_OP6_ORI:
7942       if (N32_IMM15S (insn) == 0)
7943         {
7944           /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7945              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7946           if (mach <= MACH_V2
7947               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7948             {
7949               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7950               insn_type = NDS32_INSN_MOV55;
7951             }
7952         }
7953       break;
7954
7955     case N32_OP6_SUBRI:
7956       if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7957           && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7958         {
7959           insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7960           insn_type = NDS32_INSN_NEG33;
7961         }
7962       break;
7963
7964     case N32_OP6_ANDI:
7965       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7966         {
7967           if (N32_IMM15U (insn) == 1)
7968             {
7969               insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7970               insn_type = NDS32_INSN_XLSB33;
7971             }
7972           else if (N32_IMM15U (insn) == 0x7ff)
7973             {
7974               insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7975               insn_type = NDS32_INSN_X11B33;
7976             }
7977           else if (N32_IMM15U (insn) == 0xff)
7978             {
7979               insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7980               insn_type = NDS32_INSN_ZEB33;
7981             }
7982           else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7983                    && N32_IMM15U (insn) < 256)
7984             {
7985               int imm15u = N32_IMM15U (insn);
7986
7987               if (__builtin_popcount (imm15u) == 1)
7988                 {
7989                   /* BMSKI33 */
7990                   int imm3u = __builtin_ctz (imm15u);
7991
7992                   insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7993                   insn_type = NDS32_INSN_BMSKI33;
7994                 }
7995               else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7996                 {
7997                   /* FEXTI33 */
7998                   int imm3u = __builtin_ctz (imm15u + 1) - 1;
7999
8000                   insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
8001                   insn_type = NDS32_INSN_FEXTI33;
8002                 }
8003             }
8004         }
8005       break;
8006
8007     case N32_OP6_SLTI:
8008       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8009           && IS_WITHIN_U (N32_IMM15S (insn), 5))
8010         {
8011           insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
8012           insn_type = NDS32_INSN_SLTI45;
8013         }
8014       break;
8015
8016     case N32_OP6_SLTSI:
8017       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8018           && IS_WITHIN_U (N32_IMM15S (insn), 5))
8019         {
8020           insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
8021           insn_type = NDS32_INSN_SLTSI45;
8022         }
8023       break;
8024
8025     case N32_OP6_LWI:
8026       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8027         {
8028           insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
8029           insn_type = NDS32_INSN_LWI450;
8030         }
8031       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8032                && IS_WITHIN_U (N32_IMM15S (insn), 3))
8033         {
8034           insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
8035                                 N32_IMM15S (insn));
8036           insn_type = NDS32_INSN_LWI333;
8037         }
8038       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8039                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8040         {
8041           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8042           insn_type = NDS32_INSN_LWI37;
8043         }
8044       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8045                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8046         {
8047           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
8048           insn_type = NDS32_INSN_LWI37_SP;
8049         }
8050       else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
8051                && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
8052         {
8053           insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
8054                                N32_IMM15S (insn) + 32);
8055           insn_type = NDS32_INSN_LWI45_FE;
8056         }
8057       break;
8058
8059     case N32_OP6_SWI:
8060       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8061         {
8062           insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
8063           insn_type = NDS32_INSN_SWI450;
8064         }
8065       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8066                && IS_WITHIN_U (N32_IMM15S (insn), 3))
8067         {
8068           insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
8069                                 N32_IMM15S (insn));
8070           insn_type = NDS32_INSN_SWI333;
8071         }
8072       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8073                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8074         {
8075           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8076           insn_type = NDS32_INSN_SWI37;
8077         }
8078       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8079                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8080         {
8081           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
8082           insn_type = NDS32_INSN_SWI37_SP;
8083         }
8084       break;
8085
8086     case N32_OP6_LWI_BI:
8087       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8088           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8089         {
8090           insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8091                                 N32_IMM15S (insn));
8092           insn_type = NDS32_INSN_LWI333_BI;
8093         }
8094       break;
8095
8096     case N32_OP6_SWI_BI:
8097       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8098           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8099         {
8100           insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8101                                 N32_IMM15S (insn));
8102           insn_type = NDS32_INSN_SWI333_BI;
8103         }
8104       break;
8105
8106     case N32_OP6_LHI:
8107       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8108           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8109         {
8110           insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
8111                                 N32_IMM15S (insn));
8112           insn_type = NDS32_INSN_LHI333;
8113         }
8114       break;
8115
8116     case N32_OP6_SHI:
8117       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8118           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8119         {
8120           insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
8121                                 N32_IMM15S (insn));
8122           insn_type = NDS32_INSN_SHI333;
8123         }
8124       break;
8125
8126     case N32_OP6_LBI:
8127       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8128           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8129         {
8130           insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
8131                                 N32_IMM15S (insn));
8132           insn_type = NDS32_INSN_LBI333;
8133         }
8134       break;
8135
8136     case N32_OP6_SBI:
8137       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8138           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8139         {
8140           insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
8141                                 N32_IMM15S (insn));
8142           insn_type = NDS32_INSN_SBI333;
8143         }
8144       break;
8145
8146     case N32_OP6_ALU1:
8147       return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
8148
8149     case N32_OP6_ALU2:
8150       return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
8151
8152     case N32_OP6_BR1:
8153       if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
8154         goto done;
8155
8156       if ((insn & N32_BIT (14)) == 0)
8157         {
8158           /* N32_BR1_BEQ */
8159           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8160               && N32_RT5 (insn) != REG_R5)
8161             insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
8162           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8163                    && N32_RA5 (insn) != REG_R5)
8164             insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
8165           insn_type = NDS32_INSN_BEQS38;
8166           break;
8167         }
8168       else
8169         {
8170           /* N32_BR1_BNE */
8171           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8172               && N32_RT5 (insn) != REG_R5)
8173             insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
8174           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8175                    && N32_RA5 (insn) != REG_R5)
8176             insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
8177           insn_type = NDS32_INSN_BNES38;
8178           break;
8179         }
8180       break;
8181
8182     case N32_OP6_BR2:
8183       switch (N32_BR2_SUB (insn))
8184         {
8185         case N32_BR2_BEQZ:
8186           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8187             {
8188               insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
8189               insn_type = NDS32_INSN_BEQZ38;
8190             }
8191           else if (N32_RT5 (insn) == REG_R15
8192                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
8193             {
8194               insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
8195               insn_type = NDS32_INSN_BEQZS8;
8196             }
8197           break;
8198
8199         case N32_BR2_BNEZ:
8200           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8201             {
8202               insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
8203               insn_type = NDS32_INSN_BNEZ38;
8204             }
8205           else if (N32_RT5 (insn) == REG_R15
8206                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
8207             {
8208               insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
8209               insn_type = NDS32_INSN_BNEZS8;
8210             }
8211           break;
8212
8213         case N32_BR2_SOP0:
8214           if (__GF (insn, 20, 5) == 0 && IS_WITHIN_U (N32_IMM16S (insn), 9))
8215             {
8216               insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
8217               insn_type = NDS32_INSN_IFCALL9;
8218             }
8219           break;
8220         }
8221       break;
8222
8223     case N32_OP6_JI:
8224       if ((insn & N32_BIT (24)) == 0)
8225         {
8226           /* N32_JI_J */
8227           if (IS_WITHIN_S (N32_IMM24S (insn), 8))
8228             {
8229               insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
8230               insn_type = NDS32_INSN_J8;
8231             }
8232         }
8233       break;
8234
8235     case N32_OP6_JREG:
8236       if (__GF (insn, 8, 2) != 0)
8237         goto done;
8238
8239       switch (N32_IMMU (insn, 5))
8240         {
8241         case N32_JREG_JR:
8242           if (N32_JREG_HINT (insn) == 0)
8243             {
8244               /* jr */
8245               insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
8246               insn_type = NDS32_INSN_JR5;
8247             }
8248           else if (N32_JREG_HINT (insn) == 1)
8249             {
8250               /* ret */
8251               insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
8252               insn_type = NDS32_INSN_RET5;
8253             }
8254           else if (N32_JREG_HINT (insn) == 3)
8255             {
8256               /* ifret = mov55 $sp, $sp */
8257               insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
8258               insn_type = NDS32_INSN_IFRET;
8259             }
8260           break;
8261
8262         case N32_JREG_JRAL:
8263           /* It's convertible when return rt5 is $lp and address
8264              translation is kept.  */
8265           if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
8266             {
8267               insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
8268               insn_type = NDS32_INSN_JRAL5;
8269             }
8270           break;
8271         }
8272       break;
8273
8274     case N32_OP6_MISC:
8275       if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
8276         {
8277           /* For v3, swid above 31 are used for ex9.it.  */
8278           insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
8279           insn_type = NDS32_INSN_BREAK16;
8280         }
8281       break;
8282
8283     default:
8284       /* This instruction has no 16-bit variant.  */
8285       goto done;
8286     }
8287
8288  done:
8289   /* Bit-15 of insn16 should be set for a valid instruction.  */
8290   if ((insn16 & 0x8000) == 0)
8291     return 0;
8292
8293   if (pinsn16)
8294     *pinsn16 = insn16;
8295   if (pinsn_type)
8296     *pinsn_type = insn_type;
8297   return 1;
8298 }
8299
8300 static int
8301 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
8302                           Elf_Internal_Rela *reloc)
8303 {
8304   uint16_t insn16 = 0;
8305
8306   if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
8307       || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
8308     return 0;
8309
8310   if (!N32_IS_RT3 (insn))
8311     return 0;
8312
8313   switch (N32_OP6 (insn))
8314     {
8315     case N32_OP6_LWI:
8316       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8317         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8318       break;
8319     case N32_OP6_SWI:
8320       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8321         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8322       break;
8323     case N32_OP6_HWGP:
8324       if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
8325         break;
8326
8327       if (__GF (insn, 17, 3) == 6)
8328         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
8329       else if (__GF (insn, 17, 3) == 7)
8330         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
8331       break;
8332     }
8333
8334   if ((insn16 & 0x8000) == 0)
8335     return 0;
8336
8337   *pinsn16 = insn16;
8338   return 1;
8339 }
8340
8341 /* Convert a 16-bit instruction to 32-bit one.
8342    INSN16 it the input and PINSN it the point to output.
8343    Return non-zero on successful.  Otherwise 0 is returned.  */
8344
8345 int
8346 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
8347 {
8348   uint32_t insn = 0xffffffff;
8349   unsigned long mach = bfd_get_mach (abfd);
8350
8351   /* NOTE: push25, pop25 and movd44 do not have 32-bit variants.  */
8352
8353   switch (__GF (insn16, 9, 6))
8354     {
8355     case 0x4:                   /* add45 */
8356       insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
8357                        N16_RA5 (insn16));
8358       goto done;
8359     case 0x5:                   /* sub45 */
8360       insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
8361                        N16_RA5 (insn16));
8362       goto done;
8363     case 0x6:                   /* addi45 */
8364       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8365                         N16_IMM5U (insn16));
8366       goto done;
8367     case 0x7:                   /* subi45 */
8368       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8369                         -N16_IMM5U (insn16));
8370       goto done;
8371     case 0x8:                   /* srai45 */
8372       insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
8373                        N16_IMM5U (insn16));
8374       goto done;
8375     case 0x9:                   /* srli45 */
8376       insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
8377                        N16_IMM5U (insn16));
8378       goto done;
8379     case 0xa:                   /* slli333 */
8380       insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
8381                        N16_IMM3U (insn16));
8382       goto done;
8383     case 0xc:                   /* add333 */
8384       insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
8385                        N16_RB3 (insn16));
8386       goto done;
8387     case 0xd:                   /* sub333 */
8388       insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
8389                        N16_RB3 (insn16));
8390       goto done;
8391     case 0xe:                   /* addi333 */
8392       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8393                         N16_IMM3U (insn16));
8394       goto done;
8395     case 0xf:                   /* subi333 */
8396       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8397                         -N16_IMM3U (insn16));
8398       goto done;
8399     case 0x10:                  /* lwi333 */
8400       insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
8401                         N16_IMM3U (insn16));
8402       goto done;
8403     case 0x12:                  /* lhi333 */
8404       insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
8405                         N16_IMM3U (insn16));
8406       goto done;
8407     case 0x13:                  /* lbi333 */
8408       insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
8409                         N16_IMM3U (insn16));
8410       goto done;
8411     case 0x11:                  /* lwi333.bi */
8412       insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8413                         N16_IMM3U (insn16));
8414       goto done;
8415     case 0x14:                  /* swi333 */
8416       insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
8417                         N16_IMM3U (insn16));
8418       goto done;
8419     case 0x16:                  /* shi333 */
8420       insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
8421                         N16_IMM3U (insn16));
8422       goto done;
8423     case 0x17:                  /* sbi333 */
8424       insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
8425                         N16_IMM3U (insn16));
8426       goto done;
8427     case 0x15:                  /* swi333.bi */
8428       insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8429                         N16_IMM3U (insn16));
8430       goto done;
8431     case 0x18:                  /* addri36.sp */
8432       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
8433                         N16_IMM6U (insn16) << 2);
8434       goto done;
8435     case 0x19:                  /* lwi45.fe */
8436       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
8437                         (N16_IMM5U (insn16) - 32));
8438       goto done;
8439     case 0x1a:                  /* lwi450 */
8440       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8441       goto done;
8442     case 0x1b:                  /* swi450 */
8443       insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8444       goto done;
8445
8446       /* These are r15 implied instructions.  */
8447     case 0x30:                  /* slts45 */
8448       insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8449       goto done;
8450     case 0x31:                  /* slt45 */
8451       insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8452       goto done;
8453     case 0x32:                  /* sltsi45 */
8454       insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8455       goto done;
8456     case 0x33:                  /* slti45 */
8457       insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8458       goto done;
8459     case 0x34:                  /* beqzs8, bnezs8 */
8460       if (insn16 & N32_BIT (8))
8461         insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
8462       else
8463         insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
8464       goto done;
8465
8466     case 0x35:                  /* break16, ex9.it */
8467       /* Only consider range of v3 break16.  */
8468       insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
8469       goto done;
8470
8471     case 0x3c:                  /* ifcall9 */
8472       insn = N32_BR2 (SOP0, 0, N16_IMM9U (insn16));
8473       goto done;
8474     case 0x3d:                  /* movpi45 */
8475       insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
8476       goto done;
8477
8478     case 0x3f:                  /* MISC33 */
8479       switch (insn16 & 0x7)
8480         {
8481         case 2:                 /* neg33 */
8482           insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8483           break;
8484         case 3:                 /* not33 */
8485           insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
8486                            N16_RA3 (insn16));
8487           break;
8488         case 4:                 /* mul33 */
8489           insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
8490                            N16_RA3 (insn16));
8491           break;
8492         case 5:                 /* xor33 */
8493           insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
8494                            N16_RA3 (insn16));
8495           break;
8496         case 6:                 /* and33 */
8497           insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
8498                            N16_RA3 (insn16));
8499           break;
8500         case 7:                 /* or33 */
8501           insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
8502                            N16_RA3 (insn16));
8503           break;
8504         }
8505       goto done;
8506
8507     case 0xb:
8508       switch (insn16 & 0x7)
8509         {
8510         case 0:                 /* zeb33 */
8511           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
8512           break;
8513         case 1:                 /* zeh33 */
8514           insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8515           break;
8516         case 2:                 /* seb33 */
8517           insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8518           break;
8519         case 3:                 /* seh33 */
8520           insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8521           break;
8522         case 4:                 /* xlsb33 */
8523           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
8524           break;
8525         case 5:                 /* x11b33 */
8526           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
8527           break;
8528         case 6:                 /* bmski33 */
8529           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8530                             1 << __GF (insn16, 3, 3));
8531           break;
8532         case 7:                 /* fexti33 */
8533           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8534                             (1 << (__GF (insn16, 3, 3) + 1)) - 1);
8535           break;
8536         }
8537       goto done;
8538     }
8539
8540   switch (__GF (insn16, 10, 5))
8541     {
8542     case 0x0:                   /* mov55 or ifret16 */
8543       if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
8544           && N16_RT5 (insn16) == N16_RA5 (insn16))
8545         insn = N32_JREG (JR, 0, 0, 0, 3);
8546       else
8547         insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
8548       goto done;
8549     case 0x1:                   /* movi55 */
8550       insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
8551       goto done;
8552     case 0x1b:                  /* addi10s (V2) */
8553       insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
8554       goto done;
8555     }
8556
8557   switch (__GF (insn16, 11, 4))
8558     {
8559     case 0x7:                   /* lwi37.fp/swi37.fp */
8560       if (insn16 & N32_BIT (7)) /* swi37.fp */
8561         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8562       else                      /* lwi37.fp */
8563         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8564       goto done;
8565     case 0x8:                   /* beqz38 */
8566       insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8567       goto done;
8568     case 0x9:                   /* bnez38 */
8569       insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8570       goto done;
8571     case 0xa:                   /* beqs38/j8, implied r5 */
8572       if (N16_RT38 (insn16) == 5)
8573         insn = N32_JI (J, N16_IMM8S (insn16));
8574       else
8575         insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8576       goto done;
8577     case 0xb:                   /* bnes38 and others.  */
8578       if (N16_RT38 (insn16) == 5)
8579         {
8580           switch (__GF (insn16, 5, 3))
8581             {
8582             case 0:             /* jr5 */
8583               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
8584               break;
8585             case 4:             /* ret5 */
8586               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
8587               break;
8588             case 1:             /* jral5 */
8589               insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
8590               break;
8591             case 2:             /* ex9.it imm5 */
8592               /* ex9.it had no 32-bit variantl.  */
8593               break;
8594             case 5:             /* add5.pc */
8595               /* add5.pc had no 32-bit variantl.  */
8596               break;
8597             }
8598         }
8599       else                      /* bnes38 */
8600         insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8601       goto done;
8602     case 0xe:                   /* lwi37/swi37 */
8603       if (insn16 & (1 << 7))    /* swi37.sp */
8604         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8605       else                      /* lwi37.sp */
8606         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8607       goto done;
8608     }
8609
8610  done:
8611   if (insn & 0x80000000)
8612     return 0;
8613
8614   if (pinsn)
8615     *pinsn = insn;
8616   return 1;
8617 }
8618 \f
8619
8620 static bfd_boolean
8621 is_sda_access_insn (unsigned long insn)
8622 {
8623   switch (N32_OP6 (insn))
8624     {
8625     case N32_OP6_LWI:
8626     case N32_OP6_LHI:
8627     case N32_OP6_LHSI:
8628     case N32_OP6_LBI:
8629     case N32_OP6_LBSI:
8630     case N32_OP6_SWI:
8631     case N32_OP6_SHI:
8632     case N32_OP6_SBI:
8633     case N32_OP6_LWC:
8634     case N32_OP6_LDC:
8635     case N32_OP6_SWC:
8636     case N32_OP6_SDC:
8637       return TRUE;
8638     default:
8639       ;
8640     }
8641   return FALSE;
8642 }
8643
8644 static unsigned long
8645 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
8646 {
8647   uint32_t oinsn = 0;
8648
8649   switch (type)
8650     {
8651     case R_NDS32_GOT_LO12:
8652     case R_NDS32_GOTOFF_LO12:
8653     case R_NDS32_PLTREL_LO12:
8654     case R_NDS32_PLT_GOTREL_LO12:
8655     case R_NDS32_LO12S0_RELA:
8656       switch (N32_OP6 (insn))
8657         {
8658         case N32_OP6_LBI:
8659           /* lbi.gp */
8660           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
8661           break;
8662         case N32_OP6_LBSI:
8663           /* lbsi.gp */
8664           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
8665           break;
8666         case N32_OP6_SBI:
8667           /* sbi.gp */
8668           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
8669           break;
8670         case N32_OP6_ORI:
8671           /* addi.gp */
8672           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
8673           break;
8674         }
8675       break;
8676
8677     case R_NDS32_LO12S1_RELA:
8678       switch (N32_OP6 (insn))
8679         {
8680         case N32_OP6_LHI:
8681           /* lhi.gp */
8682           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
8683           break;
8684         case N32_OP6_LHSI:
8685           /* lhsi.gp */
8686           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
8687           break;
8688         case N32_OP6_SHI:
8689           /* shi.gp */
8690           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
8691           break;
8692         }
8693       break;
8694
8695     case R_NDS32_LO12S2_RELA:
8696       switch (N32_OP6 (insn))
8697         {
8698         case N32_OP6_LWI:
8699           /* lwi.gp */
8700           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
8701           break;
8702         case N32_OP6_SWI:
8703           /* swi.gp */
8704           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
8705           break;
8706         }
8707       break;
8708
8709     case R_NDS32_LO12S2_DP_RELA:
8710     case R_NDS32_LO12S2_SP_RELA:
8711       oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
8712       break;
8713     }
8714
8715   if (oinsn)
8716     *pinsn = oinsn;
8717
8718   return oinsn != 0;
8719 }
8720
8721 /* Linker hasn't found the correct merge section for non-section symbol
8722    in relax time, this work is left to the function elf_link_input_bfd().
8723    So for non-section symbol, _bfd_merged_section_offset is also needed
8724    to find the correct symbol address.  */
8725
8726 static bfd_vma
8727 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
8728                           asection **psec, Elf_Internal_Rela *rel)
8729 {
8730   asection *sec = *psec;
8731   bfd_vma relocation;
8732
8733   relocation = (sec->output_section->vma
8734                 + sec->output_offset + sym->st_value);
8735   if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
8736     {
8737       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8738         rel->r_addend =
8739           _bfd_merged_section_offset (abfd, psec,
8740                                       elf_section_data (sec)->sec_info,
8741                                       sym->st_value + rel->r_addend);
8742       else
8743         rel->r_addend =
8744           _bfd_merged_section_offset (abfd, psec,
8745                                       elf_section_data (sec)->sec_info,
8746                                       sym->st_value) + rel->r_addend;
8747
8748       if (sec != *psec)
8749         {
8750           /* If we have changed the section, and our original section is
8751              marked with SEC_EXCLUDE, it means that the original
8752              SEC_MERGE section has been completely subsumed in some
8753              other SEC_MERGE section.  In this case, we need to leave
8754              some info around for --emit-relocs.  */
8755           if ((sec->flags & SEC_EXCLUDE) != 0)
8756             sec->kept_section = *psec;
8757           sec = *psec;
8758         }
8759       rel->r_addend -= relocation;
8760       rel->r_addend += sec->output_section->vma + sec->output_offset;
8761     }
8762   return relocation;
8763 }
8764
8765 static bfd_vma
8766 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8767                           Elf_Internal_Sym *isymbuf,
8768                           Elf_Internal_Shdr *symtab_hdr)
8769 {
8770   bfd_signed_vma foff;
8771   bfd_vma symval, addend;
8772   Elf_Internal_Rela irel_fn;
8773   Elf_Internal_Sym *isym;
8774   asection *sym_sec;
8775
8776   /* Get the value of the symbol referred to by the reloc.  */
8777   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8778     {
8779       /* A local symbol.  */
8780       isym = isymbuf + ELF32_R_SYM (irel->r_info);
8781
8782       if (isym->st_shndx == SHN_UNDEF)
8783         sym_sec = bfd_und_section_ptr;
8784       else if (isym->st_shndx == SHN_ABS)
8785         sym_sec = bfd_abs_section_ptr;
8786       else if (isym->st_shndx == SHN_COMMON)
8787         sym_sec = bfd_com_section_ptr;
8788       else
8789         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8790       memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8791       symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8792       addend = irel_fn.r_addend;
8793     }
8794   else
8795     {
8796       unsigned long indx;
8797       struct elf_link_hash_entry *h;
8798
8799       /* An external symbol.  */
8800       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8801       h = elf_sym_hashes (abfd)[indx];
8802       BFD_ASSERT (h != NULL);
8803
8804       while (h->root.type == bfd_link_hash_indirect
8805              || h->root.type == bfd_link_hash_warning)
8806         h = (struct elf_link_hash_entry *) h->root.u.i.link;
8807
8808       if (h->root.type != bfd_link_hash_defined
8809           && h->root.type != bfd_link_hash_defweak)
8810         /* This appears to be a reference to an undefined
8811            symbol.  Just ignore it--it will be caught by the
8812            regular reloc processing.  */
8813         return 0;
8814
8815       if (h->root.u.def.section->flags & SEC_MERGE)
8816         {
8817           sym_sec = h->root.u.def.section;
8818           symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8819                                                (sym_sec)->sec_info, h->root.u.def.value);
8820           symval = symval + sym_sec->output_section->vma
8821                    + sym_sec->output_offset;
8822         }
8823       else
8824         symval = (h->root.u.def.value
8825                   + h->root.u.def.section->output_section->vma
8826                   + h->root.u.def.section->output_offset);
8827       addend = irel->r_addend;
8828     }
8829
8830   foff = symval + addend;
8831
8832   return foff;
8833 }
8834
8835 static int
8836 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8837               asection *sec, Elf_Internal_Rela *rel)
8838 {
8839   bfd_byte *contents;
8840   unsigned short insn16;
8841
8842   if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8843     return FALSE;
8844   contents = elf_section_data (sec)->this_hdr.contents;
8845   insn16 = bfd_getb16 (contents + rel->r_offset);
8846   if (insn16 == NDS32_NOP16)
8847     return TRUE;
8848   return FALSE;
8849 }
8850
8851 /* It checks whether the instruction could be converted to
8852    16-bit form and returns the converted one.
8853
8854    `internal_relocs' is supposed to be sorted.  */
8855
8856 static int
8857 is_convert_32_to_16 (bfd *abfd, asection *sec,
8858                      Elf_Internal_Rela *reloc,
8859                      Elf_Internal_Rela *internal_relocs,
8860                      Elf_Internal_Rela *irelend,
8861                      uint16_t *insn16)
8862 {
8863 #define NORMAL_32_TO_16 (1 << 0)
8864 #define SPECIAL_32_TO_16 (1 << 1)
8865   bfd_byte *contents = NULL;
8866   bfd_signed_vma off;
8867   bfd_vma mem_addr;
8868   uint32_t insn = 0;
8869   Elf_Internal_Rela *pc_rel;
8870   Elf_Internal_Shdr *symtab_hdr;
8871   Elf_Internal_Sym *isymbuf = NULL;
8872   int convert_type;
8873   bfd_vma offset;
8874
8875   if (reloc->r_offset + 4 > sec->size)
8876     return FALSE;
8877
8878   offset = reloc->r_offset;
8879
8880   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8881     return FALSE;
8882   insn = bfd_getb32 (contents + offset);
8883
8884   if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8885     convert_type = NORMAL_32_TO_16;
8886   else if (special_convert_32_to_16 (insn, insn16, reloc))
8887     convert_type = SPECIAL_32_TO_16;
8888   else
8889     return FALSE;
8890
8891   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8892   if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8893     return FALSE;
8894
8895   /* Find the first relocation of the same relocation-type,
8896      so we iteratie them forward.  */
8897   pc_rel = reloc;
8898   while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8899     pc_rel--;
8900
8901   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8902     {
8903       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8904           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8905           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8906           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8907         {
8908           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8909           if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8910               || off == 0)
8911             return FALSE;
8912           break;
8913         }
8914       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8915         {
8916           /* movi => movi55  */
8917           mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8918                                                symtab_hdr);
8919           /* mem_addr is unsigned, but the value should
8920              be between [-16, 15].  */
8921           if ((mem_addr + 0x10) >> 5)
8922             return FALSE;
8923           break;
8924         }
8925       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8926                || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8927         {
8928           /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8929              because it can be relaxed to addi for TLS_LE_ADD.  */
8930           return FALSE;
8931         }
8932       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8933                 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8934                && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8935                && convert_type == SPECIAL_32_TO_16)
8936         {
8937           /* fp-as-gp
8938              We've selected a best fp-base for this access, so we can
8939              always resolve it anyway.  Do nothing.  */
8940           break;
8941         }
8942       else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8943                 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8944                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8945                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8946                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8947                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8948         {
8949           /* Prevent unresolved addi instruction translate
8950              to addi45 or addi333.  */
8951           return FALSE;
8952         }
8953       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8954         {
8955           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8956           if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8957             return FALSE;
8958           break;
8959         }
8960     }
8961
8962   return TRUE;
8963 }
8964
8965 static void
8966 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8967                     Elf_Internal_Rela *reloc,
8968                     Elf_Internal_Rela *internal_relocs,
8969                     Elf_Internal_Rela *irelend,
8970                     unsigned short insn16)
8971 {
8972   Elf_Internal_Rela *pc_rel;
8973   bfd_vma offset;
8974
8975   offset = reloc->r_offset;
8976   bfd_putb16 (insn16, contents + offset);
8977   /* Find the first relocation of the same relocation-type,
8978      so we iteratie them forward.  */
8979   pc_rel = reloc;
8980   while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8981     pc_rel--;
8982
8983   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8984     {
8985       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8986           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8987           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8988         {
8989           pc_rel->r_info =
8990             ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8991         }
8992       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8993         pc_rel->r_info =
8994           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8995       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8996         pc_rel->r_info =
8997           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8998       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8999                || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
9000         pc_rel->r_info =
9001           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
9002       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
9003         pc_rel->r_info =
9004           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
9005     }
9006 }
9007
9008 /* Find a relocation of type specified by `reloc_type'
9009    of the same r_offset with reloc.
9010    If not found, return irelend.
9011
9012    Assuming relocations are sorted by r_offset,
9013    we find the relocation from `reloc' backward untill relocs,
9014    or find it from `reloc' forward untill irelend.  */
9015
9016 static Elf_Internal_Rela *
9017 find_relocs_at_address (Elf_Internal_Rela *reloc,
9018                         Elf_Internal_Rela *relocs,
9019                         Elf_Internal_Rela *irelend,
9020                         enum elf_nds32_reloc_type reloc_type)
9021 {
9022   Elf_Internal_Rela *rel_t;
9023
9024   /* Find backward.  */
9025   for (rel_t = reloc;
9026        rel_t >= relocs && 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   /* We didn't find it backward.  Try find it forward.  */
9032   for (rel_t = reloc;
9033        rel_t < irelend && rel_t->r_offset == reloc->r_offset;
9034        rel_t++)
9035     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9036       return rel_t;
9037
9038   return irelend;
9039 }
9040
9041 /* Find a relocation of specified type and offset.
9042    `reloc' is just a refence point to find a relocation at specified offset.
9043    If not found, return irelend.
9044
9045    Assuming relocations are sorted by r_offset,
9046    we find the relocation from `reloc' backward untill relocs,
9047    or find it from `reloc' forward untill irelend.  */
9048
9049 static Elf_Internal_Rela *
9050 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
9051                              Elf_Internal_Rela *relocs,
9052                              Elf_Internal_Rela *irelend,
9053                              enum elf_nds32_reloc_type reloc_type,
9054                              bfd_vma offset_p)
9055 {
9056   Elf_Internal_Rela *rel_t = NULL;
9057
9058   /* First, we try to find a relocation of offset `offset_p',
9059      and then we use find_relocs_at_address to find specific type.  */
9060
9061   if (reloc->r_offset > offset_p)
9062     {
9063       /* Find backward.  */
9064       for (rel_t = reloc;
9065            rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
9066         /* Do nothing.  */;
9067     }
9068   else if (reloc->r_offset < offset_p)
9069     {
9070       /* Find forward.  */
9071       for (rel_t = reloc;
9072            rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
9073         /* Do nothing.  */;
9074     }
9075   else
9076     rel_t = reloc;
9077
9078   /* Not found?  */
9079   if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
9080     return irelend;
9081
9082   return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
9083 }
9084
9085 typedef struct nds32_elf_blank nds32_elf_blank_t;
9086 struct nds32_elf_blank
9087 {
9088   /* Where the blank begins.  */
9089   bfd_vma offset;
9090   /* The size of the blank.  */
9091   bfd_vma size;
9092   /* The accumulative size before this blank.  */
9093   bfd_vma total_size;
9094   nds32_elf_blank_t *next;
9095   nds32_elf_blank_t *prev;
9096 };
9097
9098 static nds32_elf_blank_t *blank_free_list = NULL;
9099
9100 static nds32_elf_blank_t *
9101 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
9102 {
9103   nds32_elf_blank_t *blank_t;
9104
9105   if (blank_free_list)
9106     {
9107       blank_t = blank_free_list;
9108       blank_free_list = blank_free_list->next;
9109     }
9110   else
9111     blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
9112
9113   if (blank_t == NULL)
9114     return NULL;
9115
9116   blank_t->offset = offset_p;
9117   blank_t->size = size_p;
9118   blank_t->total_size = 0;
9119   blank_t->next = NULL;
9120   blank_t->prev = NULL;
9121
9122   return blank_t;
9123 }
9124
9125 static void
9126 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
9127 {
9128   if (blank_free_list)
9129     {
9130       blank_free_list->prev = blank_p;
9131       blank_p->next = blank_free_list;
9132     }
9133   else
9134     blank_p->next = NULL;
9135
9136   blank_p->prev = NULL;
9137   blank_free_list = blank_p;
9138 }
9139
9140 static void
9141 clean_nds32_elf_blank (void)
9142 {
9143   nds32_elf_blank_t *blank_t;
9144
9145   while (blank_free_list)
9146     {
9147       blank_t = blank_free_list;
9148       blank_free_list = blank_free_list->next;
9149       free (blank_t);
9150     }
9151 }
9152
9153 static nds32_elf_blank_t *
9154 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
9155 {
9156   nds32_elf_blank_t *blank_t;
9157
9158   if (!blank_p)
9159     return NULL;
9160   blank_t = blank_p;
9161
9162   while (blank_t && addr < blank_t->offset)
9163     blank_t = blank_t->prev;
9164   while (blank_t && blank_t->next && addr >= blank_t->next->offset)
9165     blank_t = blank_t->next;
9166
9167   return blank_t;
9168 }
9169
9170 static bfd_vma
9171 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9172                            int overwrite)
9173 {
9174   nds32_elf_blank_t *blank_t;
9175
9176   blank_t = search_nds32_elf_blank (*blank_p, addr);
9177   if (!blank_t)
9178     return 0;
9179
9180   if (overwrite)
9181     *blank_p = blank_t;
9182
9183   if (addr < blank_t->offset + blank_t->size)
9184     return blank_t->total_size + (addr - blank_t->offset);
9185   else
9186     return blank_t->total_size + blank_t->size;
9187 }
9188
9189 static bfd_boolean
9190 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
9191 {
9192   nds32_elf_blank_t *blank_t, *blank_t2;
9193
9194   if (!*blank_p)
9195     {
9196       *blank_p = create_nds32_elf_blank (addr, len);
9197       return *blank_p ? TRUE : FALSE;
9198     }
9199
9200   blank_t = search_nds32_elf_blank (*blank_p, addr);
9201
9202   if (blank_t == NULL)
9203     {
9204       blank_t = create_nds32_elf_blank (addr, len);
9205       if (!blank_t)
9206         return FALSE;
9207       while ((*blank_p)->prev != NULL)
9208         *blank_p = (*blank_p)->prev;
9209       blank_t->next = *blank_p;
9210       (*blank_p)->prev = blank_t;
9211       (*blank_p) = blank_t;
9212       return TRUE;
9213     }
9214
9215   if (addr < blank_t->offset + blank_t->size)
9216     {
9217       /* Extend the origin blank.  */
9218       if (addr + len > blank_t->offset + blank_t->size)
9219         blank_t->size = addr + len - blank_t->offset;
9220     }
9221   else
9222     {
9223       blank_t2 = create_nds32_elf_blank (addr, len);
9224       if (!blank_t2)
9225         return FALSE;
9226       if (blank_t->next)
9227         {
9228           blank_t->next->prev = blank_t2;
9229           blank_t2->next = blank_t->next;
9230         }
9231       blank_t2->prev = blank_t;
9232       blank_t->next = blank_t2;
9233       *blank_p = blank_t2;
9234     }
9235
9236   return TRUE;
9237 }
9238
9239 static bfd_boolean
9240 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9241                                      bfd_vma len)
9242 {
9243   nds32_elf_blank_t *blank_t;
9244
9245   if (!insert_nds32_elf_blank (blank_p, addr, len))
9246     return FALSE;
9247
9248   blank_t = *blank_p;
9249
9250   if (!blank_t->prev)
9251     {
9252       blank_t->total_size = 0;
9253       blank_t = blank_t->next;
9254     }
9255
9256   while (blank_t)
9257     {
9258       blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
9259       blank_t = blank_t->next;
9260     }
9261
9262   return TRUE;
9263 }
9264
9265 static void
9266 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
9267 {
9268   nds32_elf_blank_t *blank_t;
9269   bfd_vma total_size = 0;
9270
9271   if (!blank_p)
9272     return;
9273
9274   blank_t = blank_p;
9275   while (blank_t->prev)
9276     blank_t = blank_t->prev;
9277   while (blank_t)
9278     {
9279       blank_t->total_size = total_size;
9280       total_size += blank_t->size;
9281       blank_t = blank_t->next;
9282     }
9283 }
9284
9285 static bfd_boolean
9286 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
9287                                nds32_elf_blank_t *blank_p)
9288 {
9289   Elf_Internal_Shdr *symtab_hdr;        /* Symbol table header of this bfd.  */
9290   Elf_Internal_Sym *isym = NULL;        /* Symbol table of this bfd.  */
9291   Elf_Internal_Sym *isymend;            /* Symbol entry iterator.  */
9292   unsigned int sec_shndx;               /* The section the be relaxed.  */
9293   bfd_byte *contents;                   /* Contents data of iterating section.  */
9294   Elf_Internal_Rela *internal_relocs;
9295   Elf_Internal_Rela *irel;
9296   Elf_Internal_Rela *irelend;
9297   struct elf_link_hash_entry **sym_hashes;
9298   struct elf_link_hash_entry **end_hashes;
9299   unsigned int symcount;
9300   asection *sect;
9301   nds32_elf_blank_t *blank_t;
9302   nds32_elf_blank_t *blank_t2;
9303   nds32_elf_blank_t *blank_head;
9304
9305   blank_head = blank_t = blank_p;
9306   while (blank_head->prev != NULL)
9307     blank_head = blank_head->prev;
9308   while (blank_t->next != NULL)
9309     blank_t = blank_t->next;
9310
9311   if (blank_t->offset + blank_t->size <= sec->size)
9312     {
9313       blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
9314       blank_t->next->prev = blank_t;
9315     }
9316   if (blank_head->offset > 0)
9317     {
9318       blank_head->prev = create_nds32_elf_blank (0, 0);
9319       blank_head->prev->next = blank_head;
9320       blank_head = blank_head->prev;
9321     }
9322
9323   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9324
9325   /* The deletion must stop at the next ALIGN reloc for an alignment
9326      power larger than the number of bytes we are deleting.  */
9327
9328   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9329   if (!nds32_get_local_syms (abfd, sec, &isym))
9330     return FALSE;
9331
9332   if (isym == NULL)
9333     {
9334       isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9335                                    symtab_hdr->sh_info, 0, NULL, NULL, NULL);
9336       symtab_hdr->contents = (bfd_byte *) isym;
9337     }
9338
9339   if (isym == NULL || symtab_hdr->sh_info == 0)
9340     return FALSE;
9341
9342   blank_t = blank_head;
9343   calc_nds32_blank_total (blank_head);
9344
9345   for (sect = abfd->sections; sect != NULL; sect = sect->next)
9346     {
9347       /* Adjust all the relocs.  */
9348
9349       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
9350       internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
9351                                                    TRUE /* keep_memory */);
9352       irelend = internal_relocs + sect->reloc_count;
9353
9354       blank_t = blank_head;
9355       blank_t2 = blank_head;
9356
9357       if (!(sect->flags & SEC_RELOC))
9358         continue;
9359
9360       nds32_get_section_contents (abfd, sect, &contents, TRUE);
9361
9362       for (irel = internal_relocs; irel < irelend; irel++)
9363         {
9364           bfd_vma raddr;
9365
9366           if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
9367               && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
9368               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9369             {
9370               unsigned long val = 0;
9371               unsigned long mask;
9372               long before, between;
9373               long offset = 0;
9374
9375               switch (ELF32_R_TYPE (irel->r_info))
9376                 {
9377                 case R_NDS32_DIFF8:
9378                   offset = bfd_get_8 (abfd, contents + irel->r_offset);
9379                   break;
9380                 case R_NDS32_DIFF16:
9381                   offset = bfd_get_16 (abfd, contents + irel->r_offset);
9382                   break;
9383                 case R_NDS32_DIFF32:
9384                   val = bfd_get_32 (abfd, contents + irel->r_offset);
9385                   /* Get the signed bit and mask for the high part.  The
9386                      gcc will alarm when right shift 32-bit since the
9387                      type size of long may be 32-bit.  */
9388                   mask = 0 - (val >> 31);
9389                   if (mask)
9390                     offset = (val | (mask - 0xffffffff));
9391                   else
9392                     offset = val;
9393                   break;
9394                 default:
9395                   BFD_ASSERT (0);
9396                 }
9397
9398               /*                  DIFF value
9399                 0            |encoded in location|
9400                 |------------|-------------------|---------
9401                             sym+off(addend)
9402                 -- before ---| *****************
9403                 --------------------- between ---|
9404
9405                 We only care how much data are relax between DIFF,
9406                 marked as ***.  */
9407
9408               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9409               between = get_nds32_elf_blank_total (&blank_t,
9410                                                    irel->r_addend + offset, 0);
9411               if (between == before)
9412                 goto done_adjust_diff;
9413
9414               switch (ELF32_R_TYPE (irel->r_info))
9415                 {
9416                 case R_NDS32_DIFF8:
9417                   bfd_put_8 (abfd, offset - (between - before),
9418                              contents + irel->r_offset);
9419                   break;
9420                 case R_NDS32_DIFF16:
9421                   bfd_put_16 (abfd, offset - (between - before),
9422                               contents + irel->r_offset);
9423                   break;
9424                 case R_NDS32_DIFF32:
9425                   bfd_put_32 (abfd, offset - (between - before),
9426                               contents + irel->r_offset);
9427                   break;
9428                 }
9429             }
9430           else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
9431               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9432             {
9433               bfd_vma val = 0;
9434               unsigned int len = 0;
9435               unsigned long before, between;
9436               bfd_byte *endp, *p;
9437
9438               val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
9439                                                &len);
9440
9441               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9442               between = get_nds32_elf_blank_total (&blank_t,
9443                                                    irel->r_addend + val, 0);
9444               if (between == before)
9445                 goto done_adjust_diff;
9446
9447               p = contents + irel->r_offset;
9448               endp = p + len -1;
9449               memset (p, 0x80, len);
9450               *(endp) = 0;
9451               p = write_uleb128 (p, val - (between - before)) - 1;
9452               if (p < endp)
9453                 *p |= 0x80;
9454             }
9455         done_adjust_diff:
9456
9457           if (sec == sect)
9458             {
9459               raddr = irel->r_offset;
9460               irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
9461                                                            irel->r_offset, 1);
9462
9463               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
9464                 continue;
9465               if (blank_t2 && blank_t2->next
9466                   && (blank_t2->offset > raddr
9467                       || blank_t2->next->offset <= raddr))
9468                 _bfd_error_handler
9469                   (_("%pB: error: search_nds32_elf_blank reports wrong node"),
9470                    abfd);
9471
9472               /* Mark reloc in deleted portion as NONE.
9473                  For some relocs like R_NDS32_LABEL that doesn't modify the
9474                  content in the section.  R_NDS32_LABEL doesn't belong to the
9475                  instruction in the section, so we should preserve it.  */
9476               if (raddr >= blank_t2->offset
9477                   && raddr < blank_t2->offset + blank_t2->size
9478                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
9479                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
9480                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
9481                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
9482                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
9483                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
9484                 {
9485                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
9486                                                R_NDS32_NONE);
9487                   continue;
9488                 }
9489             }
9490
9491           if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
9492               || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
9493               || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
9494             continue;
9495
9496           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
9497               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
9498               && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
9499             {
9500               if (irel->r_addend <= sec->size)
9501                 irel->r_addend -=
9502                   get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
9503             }
9504         }
9505     }
9506
9507   /* Adjust the local symbols defined in this section.  */
9508   blank_t = blank_head;
9509   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
9510     {
9511       if (isym->st_shndx == sec_shndx)
9512         {
9513           if (isym->st_value <= sec->size)
9514             {
9515               bfd_vma ahead;
9516               bfd_vma orig_addr = isym->st_value;
9517
9518               ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
9519               isym->st_value -= ahead;
9520
9521               /* Adjust function size.  */
9522               if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
9523                   && isym->st_size > 0)
9524                 isym->st_size -=
9525                   get_nds32_elf_blank_total
9526                   (&blank_t, orig_addr + isym->st_size, 0) - ahead;
9527             }
9528         }
9529     }
9530
9531   /* Now adjust the global symbols defined in this section.  */
9532   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9533               - symtab_hdr->sh_info);
9534   sym_hashes = elf_sym_hashes (abfd);
9535   end_hashes = sym_hashes + symcount;
9536   blank_t = blank_head;
9537   for (; sym_hashes < end_hashes; sym_hashes++)
9538     {
9539       struct elf_link_hash_entry *sym_hash = *sym_hashes;
9540
9541       if ((sym_hash->root.type == bfd_link_hash_defined
9542            || sym_hash->root.type == bfd_link_hash_defweak)
9543           && sym_hash->root.u.def.section == sec)
9544         {
9545           if (sym_hash->root.u.def.value <= sec->size)
9546             {
9547               bfd_vma ahead;
9548               bfd_vma orig_addr = sym_hash->root.u.def.value;
9549
9550               ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
9551               sym_hash->root.u.def.value -= ahead;
9552
9553               /* Adjust function size.  */
9554               if (sym_hash->type == STT_FUNC)
9555                 sym_hash->size -=
9556                   get_nds32_elf_blank_total
9557                   (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
9558
9559             }
9560         }
9561     }
9562
9563   contents = elf_section_data (sec)->this_hdr.contents;
9564   blank_t = blank_head;
9565   while (blank_t->next)
9566     {
9567       /* Actually delete the bytes.  */
9568
9569       /* If current blank is the last blank overlap with current section,
9570          go to finish process.  */
9571       if (sec->size <= (blank_t->next->offset))
9572         break;
9573
9574       memmove (contents + blank_t->offset - blank_t->total_size,
9575                contents + blank_t->offset + blank_t->size,
9576                blank_t->next->offset - (blank_t->offset + blank_t->size));
9577
9578       blank_t = blank_t->next;
9579     }
9580
9581   if (sec->size > (blank_t->offset + blank_t->size))
9582     {
9583       /* There are remaining code between blank and section boundary.
9584          Move the remaining code to appropriate location.  */
9585       memmove (contents + blank_t->offset - blank_t->total_size,
9586                contents + blank_t->offset + blank_t->size,
9587                sec->size - (blank_t->offset + blank_t->size));
9588       sec->size -= blank_t->total_size + blank_t->size;
9589     }
9590   else
9591     /* This blank is not entirely included in the section,
9592        reduce the section size by only part of the blank size.  */
9593     sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
9594
9595   while (blank_head)
9596     {
9597       blank_t = blank_head;
9598       blank_head = blank_head->next;
9599       remove_nds32_elf_blank (blank_t);
9600     }
9601
9602   return TRUE;
9603 }
9604
9605 /* Get the contents of a section.  */
9606
9607 static int
9608 nds32_get_section_contents (bfd *abfd, asection *sec,
9609                             bfd_byte **contents_p, bfd_boolean cache)
9610 {
9611   /* Get the section contents.  */
9612   if (elf_section_data (sec)->this_hdr.contents != NULL)
9613     *contents_p = elf_section_data (sec)->this_hdr.contents;
9614   else
9615     {
9616       if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
9617         return FALSE;
9618       if (cache)
9619         elf_section_data (sec)->this_hdr.contents = *contents_p;
9620     }
9621
9622   return TRUE;
9623 }
9624
9625 /* Get the contents of the internal symbol of abfd.  */
9626
9627 static int
9628 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
9629                       Elf_Internal_Sym **isymbuf_p)
9630 {
9631   Elf_Internal_Shdr *symtab_hdr;
9632   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9633
9634   /* Read this BFD's local symbols if we haven't done so already.  */
9635   if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
9636     {
9637       *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
9638       if (*isymbuf_p == NULL)
9639         {
9640           *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9641                                              symtab_hdr->sh_info, 0,
9642                                              NULL, NULL, NULL);
9643           if (*isymbuf_p == NULL)
9644             return FALSE;
9645         }
9646     }
9647   symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
9648
9649   return TRUE;
9650 }
9651
9652 /* Range of small data.  */
9653 static bfd_vma sdata_range[2][2];
9654 static bfd_vma const sdata_init_range[2] =
9655 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
9656
9657 static int
9658 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
9659                      bfd_byte *contents, bfd_vma addr)
9660 {
9661   unsigned long insn = bfd_getb32 (contents + addr);
9662
9663   if (insn & 0x80000000)
9664     return 2;
9665
9666   return 4;
9667 }
9668
9669 /* Set the gp relax range.  We have to measure the safe range
9670    to do gp relaxation.  */
9671
9672 static void
9673 relax_range_measurement (bfd *abfd)
9674 {
9675   asection *sec_f, *sec_b;
9676   /* For upper bound.   */
9677   bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
9678   bfd_vma align;
9679   static int decide_relax_range = 0;
9680   int i;
9681   int range_number = ARRAY_SIZE (sdata_init_range);
9682
9683   if (decide_relax_range)
9684     return;
9685   decide_relax_range = 1;
9686
9687   if (sda_rela_sec == NULL)
9688     {
9689       /* Since there is no data sections, we assume the range is page size.  */
9690       for (i = 0; i < range_number; i++)
9691         {
9692           sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9693           sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9694         }
9695       return;
9696     }
9697
9698   /* Get the biggest alignment power after the gp located section.  */
9699   sec_f = sda_rela_sec->output_section;
9700   sec_b = sec_f->next;
9701   align = 0;
9702   while (sec_b != NULL)
9703     {
9704       if ((unsigned)(1 << sec_b->alignment_power) > align)
9705         align = (1 << sec_b->alignment_power);
9706       sec_b = sec_b->next;
9707     }
9708
9709   /* I guess we can not determine the section before
9710      gp located section, so we assume the align is max page size.  */
9711   for (i = 0; i < range_number; i++)
9712     {
9713       sdata_range[i][1] = sdata_init_range[i] - align;
9714       BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9715       sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9716       BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9717     }
9718 }
9719
9720 /* These are macros used to check flags encoded in r_addend.
9721    They are only used by nds32_elf_relax_section ().  */
9722 #define GET_SEQ_LEN(addend)     ((addend) & 0x000000ff)
9723 #define IS_1ST_CONVERT(addend)  ((addend) & 0x80000000)
9724 #define IS_OPTIMIZE(addend)     ((addend) & 0x40000000)
9725 #define IS_16BIT_ON(addend)     ((addend) & 0x20000000)
9726
9727 static const char * unrecognized_reloc_msg =
9728   /* xgettext:c-format */
9729   N_("%pB: warning: %s points to unrecognized reloc at %#" PRIx64);
9730
9731 /* Relax LONGCALL1 relocation for nds32_elf_relax_section.  */
9732
9733 static bfd_boolean
9734 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9735                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9736                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9737                            Elf_Internal_Shdr *symtab_hdr)
9738 {
9739   /* There are 3 variations for LONGCALL1
9740      case 4-4-2; 16-bit on, optimize off or optimize for space
9741      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9742      ori   ta, ta, lo12(symbol) ; LO12S0
9743      jral5 ta                   ;
9744
9745      case 4-4-4; 16-bit off, optimize don't care
9746      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9747      ori   ta, ta, lo12(symbol) ; LO12S0
9748      jral  ta                   ;
9749
9750      case 4-4-4; 16-bit on, optimize for speed
9751      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9752      ori   ta, ta, lo12(symbol) ; LO12S0
9753      jral  ta                   ;
9754      Check code for -mlong-calls output.  */
9755
9756   /* Get the reloc for the address from which the register is
9757      being loaded.  This reloc will tell us which function is
9758      actually being called.  */
9759
9760   bfd_vma laddr;
9761   int seq_len;  /* Original length of instruction sequence.  */
9762   uint32_t insn;
9763   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9764   bfd_signed_vma foff;
9765   uint16_t insn16;
9766
9767   irelend = internal_relocs + sec->reloc_count;
9768   seq_len = GET_SEQ_LEN (irel->r_addend);
9769   laddr = irel->r_offset;
9770   *insn_len = seq_len;
9771
9772   hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9773                                            R_NDS32_HI20_RELA, laddr);
9774   lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9775                                            R_NDS32_LO12S0_ORI_RELA,
9776                                            laddr + 4);
9777
9778   if (hi_irelfn == irelend || lo_irelfn == irelend)
9779     {
9780       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9781                           (uint64_t) irel->r_offset);
9782       return FALSE;
9783     }
9784
9785   /* Get the value of the symbol referred to by the reloc.  */
9786   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9787
9788   /* This condition only happened when symbol is undefined.  */
9789   if (foff == 0
9790       || foff < -CONSERVATIVE_24BIT_S1
9791       || foff >= CONSERVATIVE_24BIT_S1)
9792     return FALSE;
9793
9794   /* Relax to: jal symbol; 25_PCREL.  */
9795   /* For simplicity of coding, we are going to modify the section
9796      contents, the section relocs, and the BFD symbol table.  We
9797      must tell the rest of the code not to free up this
9798      information.  It would be possible to instead create a table
9799      of changes which have to be made, as is done in coff-mips.c;
9800      that would be more work, but would require less memory when
9801      the linker is run.  */
9802
9803   /* Replace the long call with a jal.  */
9804   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9805                                R_NDS32_25_PCREL_RELA);
9806   irel->r_addend = hi_irelfn->r_addend;
9807
9808   /* We don't resolve this here but resolve it in relocate_section.  */
9809   insn = INSN_JAL;
9810   bfd_putb32 (insn, contents + irel->r_offset);
9811
9812   hi_irelfn->r_info =
9813     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9814   lo_irelfn->r_info =
9815     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9816   *insn_len = 4;
9817
9818   if (seq_len & 0x2)
9819     {
9820       insn16 = NDS32_NOP16;
9821       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9822       lo_irelfn->r_info =
9823         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9824       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9825       *insn_len += 2;
9826     }
9827   return TRUE;
9828 }
9829
9830 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9831 /* Relax LONGCALL2 relocation for nds32_elf_relax_section.  */
9832
9833 static bfd_boolean
9834 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9835                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9836                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9837                            Elf_Internal_Shdr *symtab_hdr)
9838 {
9839   /* bltz  rt, .L1   ; LONGCALL2
9840      jal   symbol   ; 25_PCREL
9841      .L1: */
9842
9843   /* Get the reloc for the address from which the register is
9844      being loaded.  This reloc will tell us which function is
9845      actually being called.  */
9846
9847   bfd_vma laddr;
9848   uint32_t insn;
9849   Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9850   bfd_signed_vma foff;
9851
9852   irelend = internal_relocs + sec->reloc_count;
9853   laddr = irel->r_offset;
9854   i1_irelfn =
9855     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9856                                  R_NDS32_25_PCREL_RELA, laddr + 4);
9857
9858   if (i1_irelfn == irelend)
9859     {
9860       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9861                           (uint64_t) irel->r_offset);
9862       return FALSE;
9863     }
9864
9865   insn = bfd_getb32 (contents + laddr);
9866
9867   /* Get the value of the symbol referred to by the reloc.  */
9868   foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr);
9869
9870   if (foff == 0
9871       || foff < -CONSERVATIVE_16BIT_S1
9872       || foff >= CONSERVATIVE_16BIT_S1)
9873     return FALSE;
9874
9875   /* Relax to   bgezal   rt, label ; 17_PCREL
9876      or         bltzal   rt, label ; 17_PCREL */
9877
9878   /* Convert to complimentary conditional call.  */
9879   insn = CONVERT_CONDITION_CALL (insn);
9880
9881   /* For simplicity of coding, we are going to modify the section
9882      contents, the section relocs, and the BFD symbol table.  We
9883      must tell the rest of the code not to free up this
9884      information.  It would be possible to instead create a table
9885      of changes which have to be made, as is done in coff-mips.c;
9886      that would be more work, but would require less memory when
9887      the linker is run.  */
9888
9889   /* Clean unnessary relocations.  */
9890   i1_irelfn->r_info =
9891     ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9892   cond_irelfn =
9893     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9894                                  R_NDS32_17_PCREL_RELA, laddr);
9895   if (cond_irelfn != irelend)
9896     cond_irelfn->r_info =
9897       ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9898
9899   /* Replace the long call with a bgezal.  */
9900   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9901                                R_NDS32_17_PCREL_RELA);
9902   irel->r_addend = i1_irelfn->r_addend;
9903
9904   bfd_putb32 (insn, contents + irel->r_offset);
9905
9906   *insn_len = 4;
9907   return TRUE;
9908 }
9909
9910 /* Relax LONGCALL3 relocation for nds32_elf_relax_section.  */
9911
9912 static bfd_boolean
9913 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9914                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9915                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9916                            Elf_Internal_Shdr *symtab_hdr)
9917 {
9918   /* There are 3 variations for LONGCALL3
9919      case 4-4-4-2; 16-bit on, optimize off or optimize for space
9920      bltz  rt,   $1                ; LONGCALL3
9921      sethi ta,   hi20(symbol)      ; HI20
9922      ori   ta, ta,  lo12(symbol)   ; LO12S0
9923      jral5 ta                      ;
9924      $1
9925
9926      case 4-4-4-4; 16-bit off, optimize don't care
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      case 4-4-4-4; 16-bit on, optimize for speed
9934      bltz  rt,   $1                ; LONGCALL3
9935      sethi ta,   hi20(symbol)      ; HI20
9936      ori   ta, ta,  lo12(symbol)   ; LO12S0
9937      jral  ta                      ;
9938      $1 */
9939
9940   /* Get the reloc for the address from which the register is
9941      being loaded.  This reloc will tell us which function is
9942      actually being called.  */
9943
9944   bfd_vma laddr;
9945   int seq_len;  /* Original length of instruction sequence.  */
9946   uint32_t insn;
9947   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9948   bfd_signed_vma foff;
9949   uint16_t insn16;
9950
9951   irelend = internal_relocs + sec->reloc_count;
9952   seq_len = GET_SEQ_LEN (irel->r_addend);
9953   laddr = irel->r_offset;
9954   *insn_len = seq_len;
9955
9956   hi_irelfn =
9957     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9958                                  R_NDS32_HI20_RELA, laddr + 4);
9959   lo_irelfn =
9960     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9961                                  R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9962
9963   if (hi_irelfn == irelend || lo_irelfn == irelend)
9964     {
9965       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9966                           (uint64_t) irel->r_offset);
9967       return FALSE;
9968     }
9969
9970   /* Get the value of the symbol referred to by the reloc.  */
9971   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9972
9973   if (foff == 0
9974       || foff < -CONSERVATIVE_24BIT_S1
9975       || foff >= CONSERVATIVE_24BIT_S1)
9976     return FALSE;
9977
9978   insn = bfd_getb32 (contents + laddr);
9979   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9980     {
9981       /* Relax to  bgezal   rt, label ; 17_PCREL
9982          or        bltzal   rt, label ; 17_PCREL */
9983
9984       /* Convert to complimentary conditional call.  */
9985       insn = CONVERT_CONDITION_CALL (insn);
9986       bfd_putb32 (insn, contents + irel->r_offset);
9987
9988       *insn_len = 4;
9989       irel->r_info =
9990         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9991       hi_irelfn->r_info =
9992         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9993       lo_irelfn->r_info =
9994         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9995
9996       cond_irelfn =
9997         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9998                                      R_NDS32_17_PCREL_RELA, laddr);
9999       if (cond_irelfn != irelend)
10000         {
10001           cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10002                                               R_NDS32_17_PCREL_RELA);
10003           cond_irelfn->r_addend = hi_irelfn->r_addend;
10004         }
10005
10006       if (seq_len & 0x2)
10007         {
10008           insn16 = NDS32_NOP16;
10009           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10010           hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10011                                             R_NDS32_INSN16);
10012           hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10013           insn_len += 2;
10014         }
10015     }
10016   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10017     {
10018       /* Relax to the following instruction sequence
10019          bltz  rt,   $1 ; LONGCALL2
10020          jal   symbol   ; 25_PCREL
10021          $1     */
10022       *insn_len = 8;
10023       insn = INSN_JAL;
10024       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10025
10026       hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10027                                         R_NDS32_25_PCREL_RELA);
10028       irel->r_info =
10029         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
10030
10031       lo_irelfn->r_info =
10032         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10033
10034       if (seq_len & 0x2)
10035         {
10036           insn16 = NDS32_NOP16;
10037           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10038           lo_irelfn->r_info =
10039             ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
10040           lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10041           insn_len += 2;
10042         }
10043     }
10044   return TRUE;
10045 }
10046
10047 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section.  */
10048
10049 static bfd_boolean
10050 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10051                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10052                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10053                            Elf_Internal_Shdr *symtab_hdr)
10054 {
10055   /* There are 3 variations for LONGJUMP1
10056      case 4-4-2; 16-bit bit on, optimize off or optimize for space
10057      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10058      ori   ta, ta, lo12(symbol)  ; LO12S0
10059      jr5   ta                    ;
10060
10061      case 4-4-4; 16-bit off, optimize don't care
10062      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10063      ori   ta, ta, lo12(symbol)  ; LO12S0
10064      jr    ta                    ;
10065
10066      case 4-4-4; 16-bit on, optimize for speed
10067      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10068      ori   ta, ta, lo12(symbol)  ; LO12S0
10069      jr    ta                    ;      */
10070
10071   /* Get the reloc for the address from which the register is
10072      being loaded.  This reloc will tell us which function is
10073      actually being called.  */
10074
10075   bfd_vma laddr;
10076   int seq_len;  /* Original length of instruction sequence.  */
10077   int insn16_on;        /* 16-bit on/off.  */
10078   uint32_t insn;
10079   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
10080   bfd_signed_vma foff;
10081   uint16_t insn16;
10082   unsigned long reloc;
10083
10084   irelend = internal_relocs + sec->reloc_count;
10085   seq_len = GET_SEQ_LEN (irel->r_addend);
10086   laddr = irel->r_offset;
10087   *insn_len = seq_len;
10088   insn16_on = IS_16BIT_ON (irel->r_addend);
10089
10090   hi_irelfn =
10091     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10092                                  R_NDS32_HI20_RELA, laddr);
10093   lo_irelfn =
10094     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10095                                  R_NDS32_LO12S0_ORI_RELA, laddr + 4);
10096   if (hi_irelfn == irelend || lo_irelfn == irelend)
10097     {
10098       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
10099                           (uint64_t) irel->r_offset);
10100       return FALSE;
10101     }
10102
10103   /* Get the value of the symbol referred to by the reloc.  */
10104   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10105
10106   if (foff == 0
10107       || foff >= CONSERVATIVE_24BIT_S1
10108       || foff < -CONSERVATIVE_24BIT_S1)
10109     return FALSE;
10110
10111   if (insn16_on
10112       && foff >= -ACCURATE_8BIT_S1
10113       && foff < ACCURATE_8BIT_S1
10114       && (seq_len & 0x2))
10115     {
10116       /* j8     label */
10117       /* 16-bit on, but not optimized for speed.  */
10118       reloc = R_NDS32_9_PCREL_RELA;
10119       insn16 = INSN_J8;
10120       bfd_putb16 (insn16, contents + irel->r_offset);
10121       *insn_len = 2;
10122       irel->r_info =
10123         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10124     }
10125   else
10126     {
10127       /* j     label */
10128       reloc = R_NDS32_25_PCREL_RELA;
10129       insn = INSN_J;
10130       bfd_putb32 (insn, contents + irel->r_offset);
10131       *insn_len = 4;
10132       irel->r_info =
10133         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
10134       irel->r_addend = 0;
10135     }
10136
10137   hi_irelfn->r_info =
10138     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10139   lo_irelfn->r_info =
10140     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10141
10142   if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
10143     {
10144       insn16 = NDS32_NOP16;
10145       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10146       lo_irelfn->r_info =
10147         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10148                       R_NDS32_INSN16);
10149       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10150       *insn_len += 2;
10151     }
10152   return TRUE;
10153 }
10154
10155 /* Revert condition branch.  This function does not check if the input
10156    instruction is condition branch or not.  */
10157
10158 static void
10159 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
10160                            uint16_t *re_insn16, uint32_t *re_insn)
10161 {
10162   uint32_t comp_insn = 0;
10163   uint16_t comp_insn16 = 0;
10164
10165   if (insn)
10166     {
10167       if (N32_OP6 (insn) == N32_OP6_BR1)
10168         {
10169           /* beqs label.  */
10170           comp_insn = (insn ^ 0x4000) & 0xffffc000;
10171           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
10172             {
10173               /* Insn can be contracted to 16-bit implied r5.  */
10174               comp_insn16 =
10175                 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
10176               comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10177             }
10178         }
10179       else if (N32_OP6 (insn) == N32_OP6_BR3)
10180         {
10181           /* bnec $ta, imm11, label.  */
10182           comp_insn = (insn ^ 0x80000) & 0xffffff00;
10183         }
10184       else
10185         {
10186           comp_insn = (insn ^ 0x10000) & 0xffffc000;
10187           if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
10188               || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
10189             {
10190               if (N32_IS_RT3 (insn))
10191                 {
10192                   /* Insn can be contracted to 16-bit.  */
10193                   comp_insn16 =
10194                     (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
10195                   comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10196                 }
10197               else if (N32_RT5 (insn) == REG_R15)
10198                 {
10199                   /* Insn can be contracted to 16-bit.  */
10200                   comp_insn16 =
10201                     (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
10202                 }
10203             }
10204         }
10205     }
10206   else
10207     {
10208       switch ((insn16 & 0xf000) >> 12)
10209         {
10210         case 0xc:
10211           /* beqz38 or bnez38 */
10212           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10213           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
10214           comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
10215           break;
10216
10217         case 0xd:
10218           /* beqs38 or bnes38 */
10219           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10220           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
10221           comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
10222             | (REG_R5 << 15);
10223           break;
10224
10225         case 0xe:
10226           /* beqzS8 or bnezS8 */
10227           comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
10228           comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
10229           comp_insn |= REG_R15 << 20;
10230           break;
10231
10232         default:
10233           break;
10234         }
10235     }
10236   if (comp_insn && re_insn)
10237     *re_insn = comp_insn;
10238   if (comp_insn16 && re_insn16)
10239     *re_insn16 = comp_insn16;
10240 }
10241
10242 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section.  */
10243
10244 static bfd_boolean
10245 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10246                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10247                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10248                            Elf_Internal_Shdr *symtab_hdr)
10249 {
10250   /* There are 3 variations for LONGJUMP2
10251      case 2-4;  1st insn convertible, 16-bit on,
10252      optimize off or optimize for space
10253      bnes38  rt, ra, $1 ; LONGJUMP2
10254      j       label      ; 25_PCREL
10255      $1:
10256
10257      case 4-4; 1st insn not convertible
10258      bne  rt, ra, $1 ; LONGJUMP2
10259      j    label      ; 25_PCREL
10260      $1:
10261
10262      case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10263      bne  rt, ra, $1 ; LONGJUMP2
10264      j    label      ; 25_PCREL
10265      $1: */
10266
10267   /* Get the reloc for the address from which the register is
10268      being loaded.  This reloc will tell us which function is
10269      actually being called.  */
10270
10271   bfd_vma laddr;
10272   int seq_len;  /* Original length of instruction sequence.  */
10273   Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
10274   int first_size;
10275   unsigned int i;
10276   bfd_signed_vma foff;
10277   uint32_t insn, re_insn = 0;
10278   uint16_t insn16, re_insn16 = 0;
10279   unsigned long reloc, cond_reloc;
10280
10281   enum elf_nds32_reloc_type checked_types[] =
10282     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10283
10284   irelend = internal_relocs + sec->reloc_count;
10285   seq_len = GET_SEQ_LEN (irel->r_addend);
10286   laddr = irel->r_offset;
10287   *insn_len = seq_len;
10288   first_size = (seq_len == 6) ? 2 : 4;
10289
10290   i2_irelfn =
10291     find_relocs_at_address_addr (irel, internal_relocs,
10292                                  irelend, R_NDS32_25_PCREL_RELA,
10293                                  laddr + first_size);
10294
10295   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10296     {
10297       cond_irelfn =
10298         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10299                                      checked_types[i], laddr);
10300       if (cond_irelfn != irelend)
10301         break;
10302     }
10303
10304   if (i2_irelfn == irelend || cond_irelfn == irelend)
10305     {
10306       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
10307                           (uint64_t) irel->r_offset);
10308       return FALSE;
10309     }
10310
10311   /* Get the value of the symbol referred to by the reloc.  */
10312   foff = calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr);
10313   if (foff == 0
10314       || foff < -CONSERVATIVE_16BIT_S1
10315       || foff >= CONSERVATIVE_16BIT_S1)
10316     return FALSE;
10317
10318   /* Get the all corresponding instructions.  */
10319   if (first_size == 4)
10320     {
10321       insn = bfd_getb32 (contents + laddr);
10322       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10323     }
10324   else
10325     {
10326       insn16 = bfd_getb16 (contents + laddr);
10327       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10328     }
10329
10330   if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
10331       && foff < ACCURATE_8BIT_S1 - first_size)
10332     {
10333       if (first_size == 4)
10334         {
10335           /* Don't convert it to 16-bit now, keep this as relaxable for
10336              ``label reloc; INSN16''.  */
10337
10338           /* Save comp_insn32 to buffer.  */
10339           bfd_putb32 (re_insn, contents + irel->r_offset);
10340           *insn_len = 4;
10341           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10342             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10343           cond_reloc = R_NDS32_INSN16;
10344         }
10345       else
10346         {
10347           bfd_putb16 (re_insn16, contents + irel->r_offset);
10348           *insn_len = 2;
10349           reloc = R_NDS32_9_PCREL_RELA;
10350           cond_reloc = R_NDS32_NONE;
10351         }
10352     }
10353   else if (N32_OP6 (re_insn) == N32_OP6_BR1
10354            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10355                && foff < ACCURATE_14BIT_S1 - first_size))
10356     {
10357       /* beqs     label    ; 15_PCREL */
10358       bfd_putb32 (re_insn, contents + irel->r_offset);
10359       *insn_len = 4;
10360       reloc = R_NDS32_15_PCREL_RELA;
10361       cond_reloc = R_NDS32_NONE;
10362     }
10363   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10364            && foff >= -CONSERVATIVE_16BIT_S1
10365            && foff < CONSERVATIVE_16BIT_S1)
10366     {
10367       /* beqz     label ; 17_PCREL */
10368       bfd_putb32 (re_insn, contents + irel->r_offset);
10369       *insn_len = 4;
10370       reloc = R_NDS32_17_PCREL_RELA;
10371       cond_reloc = R_NDS32_NONE;
10372     }
10373   else
10374     return FALSE;
10375
10376   /* Set all relocations.  */
10377   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
10378   irel->r_addend = i2_irelfn->r_addend;
10379
10380   cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10381                                       cond_reloc);
10382   cond_irelfn->r_addend = 0;
10383
10384   if ((seq_len ^ *insn_len ) & 0x2)
10385     {
10386       insn16 = NDS32_NOP16;
10387       bfd_putb16 (insn16, contents + irel->r_offset + 4);
10388       i2_irelfn->r_offset = 4;
10389       i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10390                                         R_NDS32_INSN16);
10391       i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10392       *insn_len += 2;
10393     }
10394   else
10395     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10396                                       R_NDS32_NONE);
10397   return TRUE;
10398 }
10399
10400 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section.  */
10401
10402 static bfd_boolean
10403 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10404                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10405                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10406                            Elf_Internal_Shdr *symtab_hdr)
10407 {
10408   /* There are 5 variations for LONGJUMP3
10409      case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
10410      optimize off or optimize for space
10411      bnes38   rt, ra, $1            ; LONGJUMP3
10412      sethi    ta, hi20(symbol)      ; HI20
10413      ori      ta, ta, lo12(symbol)  ; LO12S0
10414      jr5      ta                    ;
10415      $1:                            ;
10416
10417      case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
10418      bnes38   rt, ra, $1           ; LONGJUMP3
10419      sethi    ta, hi20(symbol)     ; HI20
10420      ori      ta, ta, lo12(symbol) ; LO12S0
10421      jr5      ta                   ;
10422      $1:                           ; LABEL
10423
10424      case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
10425      optimize off or optimize for space
10426      bne   rt, ra, $1           ; LONGJUMP3
10427      sethi ta, hi20(symbol)     ; HI20
10428      ori   ta, ta, lo12(symbol) ; LO12S0
10429      jr5   ta                   ;
10430      $1:                        ;
10431
10432      case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
10433      16-bit off if no INSN16
10434      bne   rt, ra, $1           ; LONGJUMP3
10435      sethi ta, hi20(symbol)     ; HI20
10436      ori   ta, ta, lo12(symbol) ; LO12S0
10437      jr    ta                   ;
10438      $1:                        ;
10439
10440      case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
10441      16-bit off if no INSN16
10442      bne   rt, ra, $1           ; LONGJUMP3
10443      sethi ta, hi20(symbol)     ; HI20
10444      ori   ta, ta, lo12(symbol) ; LO12S0
10445      jr    ta                   ;
10446      $1:                        ; LABEL */
10447
10448   /* Get the reloc for the address from which the register is
10449      being loaded.  This reloc will tell us which function is
10450      actually being called.  */
10451   enum elf_nds32_reloc_type checked_types[] =
10452     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10453
10454   int reloc_off = 0, cond_removed = 0, convertible;
10455   bfd_vma laddr;
10456   int seq_len;  /* Original length of instruction sequence.  */
10457   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
10458   int first_size;
10459   unsigned int i;
10460   bfd_signed_vma foff;
10461   uint32_t insn, re_insn = 0;
10462   uint16_t insn16, re_insn16 = 0;
10463   unsigned long reloc, cond_reloc;
10464
10465   irelend = internal_relocs + sec->reloc_count;
10466   seq_len = GET_SEQ_LEN (irel->r_addend);
10467   laddr = irel->r_offset;
10468   *insn_len = seq_len;
10469
10470   convertible = IS_1ST_CONVERT (irel->r_addend);
10471
10472   if (convertible)
10473     first_size = 2;
10474   else
10475     first_size = 4;
10476
10477   /* Get all needed relocations.  */
10478   hi_irelfn =
10479     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10480                                  R_NDS32_HI20_RELA, laddr + first_size);
10481   lo_irelfn =
10482     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10483                                  R_NDS32_LO12S0_ORI_RELA,
10484                                  laddr + first_size + 4);
10485
10486   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10487     {
10488       cond_irelfn =
10489         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10490                                      checked_types[i], laddr);
10491       if (cond_irelfn != irelend)
10492         break;
10493     }
10494
10495   if (hi_irelfn == irelend
10496       || lo_irelfn == irelend
10497       || cond_irelfn == irelend)
10498     {
10499       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
10500                           (uint64_t) irel->r_offset);
10501       return FALSE;
10502     }
10503
10504   /* Get the value of the symbol referred to by the reloc.  */
10505   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10506
10507   if (foff == 0
10508       || foff < -CONSERVATIVE_24BIT_S1
10509       || foff >= CONSERVATIVE_24BIT_S1)
10510     return FALSE;
10511
10512   /* Get the all corresponding instructions.  */
10513   if (first_size == 4)
10514     {
10515       insn = bfd_getb32 (contents + laddr);
10516       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10517     }
10518   else
10519     {
10520       insn16 = bfd_getb16 (contents + laddr);
10521       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10522     }
10523
10524   /* For simplicity of coding, we are going to modify the section
10525      contents, the section relocs, and the BFD symbol table.  We
10526      must tell the rest of the code not to free up this
10527      information.  It would be possible to instead create a table
10528      of changes which have to be made, as is done in coff-mips.c;
10529      that would be more work, but would require less memory when
10530      the linker is run.  */
10531
10532   if (re_insn16
10533       && foff >= -ACCURATE_8BIT_S1 - first_size
10534       && foff < ACCURATE_8BIT_S1 - first_size)
10535     {
10536       if (!(seq_len & 0x2))
10537         {
10538           /* Don't convert it to 16-bit now, keep this as relaxable
10539              for ``label reloc; INSN1a''6.  */
10540           /* Save comp_insn32 to buffer.  */
10541           bfd_putb32 (re_insn, contents + irel->r_offset);
10542           *insn_len = 4;
10543           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10544             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10545           cond_reloc = R_NDS32_INSN16;
10546         }
10547       else
10548         {
10549           /* Not optimize for speed; convert sequence to 16-bit.  */
10550           /* Save comp_insn16 to buffer.  */
10551           bfd_putb16 (re_insn16, contents + irel->r_offset);
10552           *insn_len = 2;
10553           reloc = R_NDS32_9_PCREL_RELA;
10554           cond_reloc = R_NDS32_NONE;
10555         }
10556       cond_removed = 1;
10557     }
10558   else if (N32_OP6 (re_insn) == N32_OP6_BR1
10559            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10560                && foff < ACCURATE_14BIT_S1 - first_size))
10561     {
10562       /* beqs     label    ; 15_PCREL */
10563       bfd_putb32 (re_insn, contents + irel->r_offset);
10564       *insn_len = 4;
10565       reloc = R_NDS32_15_PCREL_RELA;
10566       cond_reloc = R_NDS32_NONE;
10567       cond_removed = 1;
10568     }
10569   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10570            && foff >= -CONSERVATIVE_16BIT_S1
10571            && foff < CONSERVATIVE_16BIT_S1)
10572     {
10573       /* beqz     label ; 17_PCREL */
10574       bfd_putb32 (re_insn, contents + irel->r_offset);
10575       *insn_len = 4;
10576       reloc = R_NDS32_17_PCREL_RELA;
10577       cond_reloc = R_NDS32_NONE;
10578       cond_removed = 1;
10579     }
10580   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10581            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10582     {
10583       /* Relax to one of the following 3 variations
10584
10585          case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
10586          for space
10587          bnes38  rt, $1 ; LONGJUMP2
10588          j       label  ; 25_PCREL
10589          $1
10590
10591          case 4-4; 1st insn not convertible, others don't care
10592          bne   rt, ra, $1 ; LONGJUMP2
10593          j     label      ; 25_PCREL
10594          $1
10595
10596          case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10597          bne   rt, ra, $1 ; LONGJUMP2
10598          j     label      ; 25_PCREL
10599          $1 */
10600
10601       /* Offset for first instruction.  */
10602
10603       /* Use j label as second instruction.  */
10604       *insn_len = 4 + first_size;
10605       insn = INSN_J;
10606       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10607       reloc = R_NDS32_LONGJUMP2;
10608       cond_reloc = R_NDS32_25_PLTREL;
10609     }
10610     else
10611       return FALSE;
10612
10613     if (cond_removed == 1)
10614       {
10615         /* Set all relocations.  */
10616         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10617         irel->r_addend = hi_irelfn->r_addend;
10618
10619         cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10620                                             cond_reloc);
10621         cond_irelfn->r_addend = 0;
10622         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10623                                           R_NDS32_NONE);
10624       }
10625     else
10626       {
10627         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10628         irel->r_addend = irel->r_addend;
10629         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10630                                           cond_reloc);
10631       }
10632
10633   if ((seq_len ^ *insn_len ) & 0x2)
10634     {
10635       insn16 = NDS32_NOP16;
10636       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10637       lo_irelfn->r_offset = *insn_len;
10638       lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10639                                         R_NDS32_INSN16);
10640       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10641       *insn_len += 2;
10642     }
10643   else
10644     lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10645                                       R_NDS32_NONE);
10646   return TRUE;
10647 }
10648
10649 /* Relax LONGCALL4 relocation for nds32_elf_relax_section.  */
10650
10651 static bfd_boolean
10652 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10653                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10654                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10655                            Elf_Internal_Shdr *symtab_hdr)
10656 {
10657   /* The pattern for LONGCALL4.  Support for function cse.
10658      sethi ta, hi20(symbol)     ; LONGCALL4/HI20
10659      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10660      jral  ta                   ; PTR_RES/EMPTY/INSN16  */
10661
10662   bfd_vma laddr;
10663   uint32_t insn;
10664   Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
10665   Elf_Internal_Rela *irelend;
10666   bfd_signed_vma foff;
10667
10668   irelend = internal_relocs + sec->reloc_count;
10669   laddr = irel->r_offset;
10670
10671   /* Get the reloc for the address from which the register is
10672      being loaded.  This reloc will tell us which function is
10673      actually being called.  */
10674   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10675                                          R_NDS32_HI20_RELA, laddr);
10676
10677   if (hi_irel == irelend)
10678     {
10679       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10680                           (uint64_t) irel->r_offset);
10681       return FALSE;
10682     }
10683
10684   /* Get the value of the symbol referred to by the reloc.  */
10685   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10686
10687   /* This condition only happened when symbol is undefined.  */
10688   if (foff == 0
10689       || foff < -CONSERVATIVE_24BIT_S1
10690       || foff >= CONSERVATIVE_24BIT_S1)
10691     return FALSE;
10692
10693   /* Relax to: jal symbol; 25_PCREL.  */
10694   /* For simplicity of coding, we are going to modify the section
10695      contents, the section relocs, and the BFD symbol table.  We
10696      must tell the rest of the code not to free up this
10697      information.  It would be possible to instead create a table
10698      of changes which have to be made, as is done in coff-mips.c;
10699      that would be more work, but would require less memory when
10700      the linker is run.  */
10701
10702   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10703                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
10704   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10705                                           R_NDS32_EMPTY, irel->r_addend);
10706
10707   if (ptr_irel == irelend || em_irel == irelend)
10708     {
10709       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10710                           (uint64_t) irel->r_offset);
10711       return FALSE;
10712     }
10713   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10714   insn = bfd_getb32 (contents + irel->r_addend);
10715   if (insn & 0x80000000)
10716     return FALSE;
10717
10718   /* Replace the long call with a jal.  */
10719   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10720                                   R_NDS32_25_PCREL_RELA);
10721   ptr_irel->r_addend = 1;
10722
10723   /* We don't resolve this here but resolve it in relocate_section.  */
10724   insn = INSN_JAL;
10725   bfd_putb32 (insn, contents + em_irel->r_offset);
10726
10727   irel->r_info =
10728     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10729
10730   /* If there is function cse, HI20 can not remove now.  */
10731   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10732                                            R_NDS32_LONGCALL4, laddr);
10733   if (call_irel == irelend)
10734     {
10735       *insn_len = 0;
10736       hi_irel->r_info =
10737         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10738     }
10739
10740   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10741                                           R_NDS32_INSN16, irel->r_addend);
10742   if (insn_irel != irelend)
10743     insn_irel->r_info =
10744       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10745
10746   return TRUE;
10747 }
10748
10749 /* Relax LONGCALL5 relocation for nds32_elf_relax_section.  */
10750
10751 static bfd_boolean
10752 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10753                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10754                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10755                            Elf_Internal_Shdr *symtab_hdr)
10756 {
10757   /* The pattern for LONGCALL5.
10758      bltz  rt, .L1      ; LONGCALL5/17_PCREL
10759      jal   symbol       ; 25_PCREL
10760      .L1:  */
10761
10762   bfd_vma laddr;
10763   uint32_t insn;
10764   Elf_Internal_Rela *cond_irel, *irelend;
10765   bfd_signed_vma foff;
10766
10767   irelend = internal_relocs + sec->reloc_count;
10768   laddr = irel->r_offset;
10769   insn = bfd_getb32 (contents + laddr);
10770
10771   /* Get the reloc for the address from which the register is
10772      being loaded.  This reloc will tell us which function is
10773      actually being called.  */
10774   cond_irel =
10775     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10776                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
10777   if (cond_irel == irelend)
10778     {
10779       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10780                           (uint64_t) irel->r_offset);
10781       return FALSE;
10782     }
10783
10784   /* Get the value of the symbol referred to by the reloc.  */
10785   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
10786
10787   if (foff == 0
10788       || foff < -CONSERVATIVE_16BIT_S1
10789       || foff >= CONSERVATIVE_16BIT_S1)
10790     return FALSE;
10791
10792   /* Relax to   bgezal   rt, label ; 17_PCREL
10793      or         bltzal   rt, label ; 17_PCREL.  */
10794
10795   /* Convert to complimentary conditional call.  */
10796   insn = CONVERT_CONDITION_CALL (insn);
10797
10798   /* For simplicity of coding, we are going to modify the section
10799      contents, the section relocs, and the BFD symbol table.  We
10800      must tell the rest of the code not to free up this
10801      information.  It would be possible to instead create a table
10802      of changes which have to be made, as is done in coff-mips.c;
10803      that would be more work, but would require less memory when
10804      the linker is run.  */
10805
10806   /* Modify relocation and contents.  */
10807   cond_irel->r_info =
10808     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10809
10810   /* Replace the long call with a bgezal.  */
10811   bfd_putb32 (insn, contents + cond_irel->r_offset);
10812   *insn_len = 0;
10813
10814   /* Clean unnessary relocations.  */
10815   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10816
10817   cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10818                                            R_NDS32_17_PCREL_RELA, laddr);
10819   cond_irel->r_info =
10820     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10821
10822   return TRUE;
10823 }
10824
10825 /* Relax LONGCALL6 relocation for nds32_elf_relax_section.  */
10826
10827 static bfd_boolean
10828 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10829                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10830                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10831                            Elf_Internal_Shdr *symtab_hdr)
10832 {
10833   /* The pattern for LONGCALL6.
10834      bltz  rt,   .L1                    ; LONGCALL6/17_PCREL
10835      sethi ta,   hi20(symbol)           ; HI20/PTR
10836      ori   ta, ta,  lo12(symbol)        ; LO12S0_ORI/PTR
10837      jral  ta                           ; PTR_RES/EMPTY/INSN16
10838      .L1  */
10839
10840   bfd_vma laddr;
10841   uint32_t insn;
10842   Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10843   bfd_signed_vma foff;
10844
10845   irelend = internal_relocs + sec->reloc_count;
10846   laddr = irel->r_offset;
10847
10848   /* Get the reloc for the address from which the register is
10849      being loaded.  This reloc will tell us which function is
10850      actually being called.  */
10851   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10852                                          R_NDS32_EMPTY, irel->r_addend);
10853
10854   if (em_irel == irelend)
10855     {
10856       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10857                           (uint64_t) irel->r_offset);
10858       return FALSE;
10859     }
10860
10861   /* Get the value of the symbol referred to by the reloc.  */
10862   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
10863
10864   if (foff == 0
10865       || foff < -CONSERVATIVE_24BIT_S1
10866       || foff >= CONSERVATIVE_24BIT_S1)
10867     return FALSE;
10868
10869   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10870   insn = bfd_getb32 (contents + irel->r_addend);
10871   if (insn & 0x80000000)
10872     return FALSE;
10873
10874   insn = bfd_getb32 (contents + laddr);
10875   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10876     {
10877       /* Relax to  bgezal   rt, label ; 17_PCREL
10878          or        bltzal   rt, label ; 17_PCREL.  */
10879
10880       /* Convert to complimentary conditional call.  */
10881       *insn_len = 0;
10882       insn = CONVERT_CONDITION_CALL (insn);
10883       bfd_putb32 (insn, contents + em_irel->r_offset);
10884
10885       em_irel->r_info =
10886         ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10887
10888       /* Set resolved relocation.  */
10889       cond_irel =
10890         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10891                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10892       if (cond_irel == irelend)
10893         {
10894           _bfd_error_handler (unrecognized_reloc_msg, abfd,
10895                               "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10896           return FALSE;
10897         }
10898       cond_irel->r_addend = 1;
10899
10900       /* Clear relocations.  */
10901
10902       irel->r_info =
10903         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10904
10905       cond_irel =
10906         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10907                                      R_NDS32_17_PCREL_RELA, laddr);
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       cond_irel =
10913         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10914                                      R_NDS32_INSN16, irel->r_addend);
10915       if (cond_irel != irelend)
10916         cond_irel->r_info =
10917           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10918
10919     }
10920   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10921     {
10922       /* Relax to the following instruction sequence
10923          bltz  rt, .L1  ; LONGCALL2/17_PCREL
10924          jal   symbol   ; 25_PCREL/PTR_RES
10925          .L1  */
10926       *insn_len = 4;
10927       /* Convert instruction.  */
10928       insn = INSN_JAL;
10929       bfd_putb32 (insn, contents + em_irel->r_offset);
10930
10931       /* Convert relocations.  */
10932       em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10933                                       R_NDS32_25_PCREL_RELA);
10934       irel->r_info =
10935         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10936
10937       /* Set resolved relocation.  */
10938       cond_irel =
10939         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10940                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10941       if (cond_irel == irelend)
10942         {
10943           _bfd_error_handler (unrecognized_reloc_msg, abfd,
10944                               "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10945           return FALSE;
10946         }
10947       cond_irel->r_addend = 1;
10948
10949       cond_irel =
10950         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10951                                      R_NDS32_INSN16, irel->r_addend);
10952       if (cond_irel != irelend)
10953         cond_irel->r_info =
10954           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10955     }
10956   return TRUE;
10957 }
10958
10959 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section.  */
10960
10961 static bfd_boolean
10962 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10963                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10964                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10965                            Elf_Internal_Shdr *symtab_hdr)
10966 {
10967   /* The pattern for LONGJUMP4.
10968      sethi ta, hi20(symbol)     ; LONGJUMP4/HI20
10969      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10970      jr    ta                   ; PTR_RES/INSN16/EMPTY  */
10971
10972   bfd_vma laddr;
10973   int seq_len;  /* Original length of instruction sequence.  */
10974   uint32_t insn;
10975   Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10976   bfd_signed_vma foff;
10977
10978   irelend = internal_relocs + sec->reloc_count;
10979   seq_len = GET_SEQ_LEN (irel->r_addend);
10980   laddr = irel->r_offset;
10981   *insn_len = seq_len;
10982
10983   /* Get the reloc for the address from which the register is
10984      being loaded.  This reloc will tell us which function is
10985      actually being called.  */
10986
10987   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10988                                          R_NDS32_HI20_RELA, laddr);
10989
10990   if (hi_irel == irelend)
10991     {
10992       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10993                           (uint64_t) irel->r_offset);
10994       return FALSE;
10995     }
10996
10997   /* Get the value of the symbol referred to by the reloc.  */
10998   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10999
11000   if (foff == 0
11001       || foff >= CONSERVATIVE_24BIT_S1
11002       || foff < -CONSERVATIVE_24BIT_S1)
11003     return FALSE;
11004
11005   /* Convert it to "j label", it may be converted to j8 in the final
11006      pass of relaxation.  Therefore, we do not consider this currently.  */
11007   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11008                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
11009   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11010                                          R_NDS32_EMPTY, irel->r_addend);
11011
11012   if (ptr_irel == irelend || em_irel == irelend)
11013     {
11014       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
11015                           (uint64_t) irel->r_offset);
11016       return FALSE;
11017     }
11018
11019   em_irel->r_info =
11020     ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
11021   ptr_irel->r_addend = 1;
11022
11023   /* Write instruction.  */
11024   insn = INSN_J;
11025   bfd_putb32 (insn, contents + em_irel->r_offset);
11026
11027   /* Clear relocations.  */
11028   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11029
11030   /* If there is function cse, HI20 can not remove now.  */
11031   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11032                                            R_NDS32_LONGJUMP4, laddr);
11033   if (call_irel == irelend)
11034     {
11035       *insn_len = 0;
11036       hi_irel->r_info =
11037         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
11038     }
11039
11040   return TRUE;
11041 }
11042
11043 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section.  */
11044
11045 static bfd_boolean
11046 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11047                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11048                            int *seq_len, bfd_byte *contents,
11049                            Elf_Internal_Sym *isymbuf,
11050                            Elf_Internal_Shdr *symtab_hdr)
11051 {
11052   /* There are 2 variations for LONGJUMP5
11053      case 2-4;  1st insn convertible, 16-bit on.
11054      bnes38  rt, ra, .L1        ; LONGJUMP5/9_PCREL/INSN16
11055      j       label              ; 25_PCREL/INSN16
11056      $1:
11057
11058      case 4-4; 1st insn not convertible
11059      bne  rt, ra, .L1   ; LONGJUMP5/15_PCREL/INSN16
11060      j    label         ; 25_PCREL/INSN16
11061      .L1:  */
11062
11063   bfd_vma laddr;
11064   Elf_Internal_Rela *cond_irel,  *irelend;
11065   unsigned int i;
11066   bfd_signed_vma foff;
11067   uint32_t insn, re_insn = 0;
11068   uint16_t insn16, re_insn16 = 0;
11069   unsigned long reloc;
11070
11071   enum elf_nds32_reloc_type checked_types[] =
11072     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11073       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11074
11075   irelend = internal_relocs + sec->reloc_count;
11076   laddr = irel->r_offset;
11077
11078   /* Get the reloc for the address from which the register is
11079      being loaded.  This reloc will tell us which function is
11080      actually being called.  */
11081
11082   cond_irel =
11083     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11084                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
11085   if (cond_irel == irelend)
11086     {
11087       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
11088                           (uint64_t) irel->r_offset);
11089       return FALSE;
11090     }
11091
11092   /* Get the value of the symbol referred to by the reloc.  */
11093   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11094
11095   if (foff == 0
11096       || foff < -CONSERVATIVE_16BIT_S1
11097       || foff >= CONSERVATIVE_16BIT_S1)
11098     return FALSE;
11099
11100   /* Get the all corresponding instructions.  */
11101   insn = bfd_getb32 (contents + laddr);
11102   /* Check instruction size.  */
11103   if (insn & 0x80000000)
11104     {
11105       *seq_len = 0;
11106       insn16 = insn >> 16;
11107       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11108     }
11109   else
11110     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11111
11112   if (N32_OP6 (re_insn) == N32_OP6_BR1
11113       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11114     {
11115       /* beqs label ; 15_PCREL.  */
11116       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11117       reloc = R_NDS32_15_PCREL_RELA;
11118     }
11119   else if (N32_OP6 (re_insn) == N32_OP6_BR2
11120            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11121     {
11122       /* beqz label ; 17_PCREL.  */
11123       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11124       reloc = R_NDS32_17_PCREL_RELA;
11125     }
11126   else if ( N32_OP6 (re_insn) == N32_OP6_BR3
11127            && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
11128     {
11129       /* beqc label ; 9_PCREL.  */
11130       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11131       reloc = R_NDS32_WORD_9_PCREL_RELA;
11132     }
11133   else
11134     return FALSE;
11135
11136   /* Set all relocations.  */
11137   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
11138
11139   /* Clean relocations.  */
11140   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11141   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11142     {
11143       cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11144                                                checked_types[i], laddr);
11145       if (cond_irel != irelend)
11146         {
11147           if (*seq_len == 0
11148               && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11149             {
11150               /* If the branch instruction is 2 byte, it cannot remove
11151                  directly.  Only convert it to nop16 and remove it after
11152                  checking alignment issue.  */
11153               insn16 = NDS32_NOP16;
11154               bfd_putb16 (insn16, contents + laddr);
11155               cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11156             }
11157           else
11158             cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11159                                               R_NDS32_NONE);
11160         }
11161     }
11162   *insn_len = 0;
11163
11164   return TRUE;
11165 }
11166
11167 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section.  */
11168
11169 static bfd_boolean
11170 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11171                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11172                            int *seq_len, bfd_byte *contents,
11173                            Elf_Internal_Sym *isymbuf,
11174                            Elf_Internal_Shdr *symtab_hdr)
11175 {
11176   /* There are 5 variations for LONGJUMP6
11177      case : 2-4-4-4; 1st insn convertible, 16-bit on.
11178      bnes38   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      case : 4-4-4-4; 1st insn not convertible, 16-bit on.
11185      bne   rt, ra, .L1          ; LONGJUMP6/15_PCREL/INSN16
11186      sethi ta, hi20(symbol)     ; HI20/PTR
11187      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11188      jr    ta                   ; PTR_RES/INSN16/EMPTY
11189      .L1:  */
11190
11191   enum elf_nds32_reloc_type checked_types[] =
11192     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11193       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11194
11195   int reloc_off = 0, cond_removed = 0;
11196   bfd_vma laddr;
11197   Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
11198   unsigned int i;
11199   bfd_signed_vma foff;
11200   uint32_t insn, re_insn = 0;
11201   uint16_t insn16, re_insn16 = 0;
11202   unsigned long reloc;
11203
11204   irelend = internal_relocs + sec->reloc_count;
11205   laddr = irel->r_offset;
11206
11207   /* Get the reloc for the address from which the register is
11208      being loaded.  This reloc will tell us which function is
11209      actually being called.  */
11210   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11211                                          R_NDS32_EMPTY, irel->r_addend);
11212
11213   if (em_irel == irelend)
11214     {
11215       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
11216                           (uint64_t) irel->r_offset);
11217       return FALSE;
11218     }
11219
11220   /* Get the value of the symbol referred to by the reloc.  */
11221   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
11222
11223   if (foff == 0
11224       || foff < -CONSERVATIVE_24BIT_S1
11225       || foff >= CONSERVATIVE_24BIT_S1)
11226     return FALSE;
11227
11228   insn = bfd_getb32 (contents + laddr);
11229   /* Check instruction size.  */
11230   if (insn & 0x80000000)
11231     {
11232       *seq_len = 0;
11233       insn16 = insn >> 16;
11234       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11235     }
11236   else
11237     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11238
11239   /* For simplicity of coding, we are going to modify the section
11240      contents, the section relocs, and the BFD symbol table.  We
11241      must tell the rest of the code not to free up this
11242      information.  It would be possible to instead create a table
11243      of changes which have to be made, as is done in coff-mips.c;
11244      that would be more work, but would require less memory when
11245      the linker is run.  */
11246
11247   if (N32_OP6 (re_insn) == N32_OP6_BR1
11248       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11249     {
11250       /* beqs     label    ; 15_PCREL.  */
11251       bfd_putb32 (re_insn, contents + em_irel->r_offset);
11252       reloc = R_NDS32_15_PCREL_RELA;
11253       cond_removed = 1;
11254     }
11255   else if (N32_OP6 (re_insn) == N32_OP6_BR2
11256            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11257     {
11258       /* beqz     label ; 17_PCREL.  */
11259       bfd_putb32 (re_insn, contents + em_irel->r_offset);
11260       reloc = R_NDS32_17_PCREL_RELA;
11261       cond_removed = 1;
11262     }
11263   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
11264            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
11265     {
11266       /* Relax to one of the following 2 variations
11267
11268          case 2-4;  1st insn convertible, 16-bit on.
11269          bnes38  rt, ra, .L1    ; LONGJUMP5/9_PCREL/INSN16
11270          j       label          ; 25_PCREL/INSN16
11271          $1:
11272
11273          case 4-4; 1st insn not convertible
11274          bne  rt, ra, .L1       ; LONGJUMP5/15_PCREL/INSN16
11275          j    label             ; 25_PCREL/INSN16
11276          .L1:  */
11277
11278       /* Use j label as second instruction.  */
11279       insn = INSN_J;
11280       reloc = R_NDS32_25_PCREL_RELA;
11281       bfd_putb32 (insn, contents + em_irel->r_offset);
11282     }
11283   else
11284     return FALSE;
11285
11286   /* Set all relocations.  */
11287   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
11288
11289   cond_irel =
11290     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11291                                  R_NDS32_PTR_RESOLVED, em_irel->r_offset);
11292   cond_irel->r_addend = 1;
11293
11294   /* Use INSN16 of first branch instruction to distinguish if keeping
11295      INSN16 of final instruction or not.  */
11296   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11297                                            R_NDS32_INSN16, irel->r_offset);
11298   if (insn_irel == irelend)
11299     {
11300       /* Clean the final INSN16.  */
11301       insn_irel =
11302         find_relocs_at_address_addr (irel, internal_relocs, irelend,
11303                                      R_NDS32_INSN16, em_irel->r_offset);
11304       insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11305                                         R_NDS32_NONE);
11306     }
11307
11308   if (cond_removed == 1)
11309     {
11310       *insn_len = 0;
11311
11312       /* Clear relocations.  */
11313       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11314
11315       for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11316         {
11317           cond_irel =
11318             find_relocs_at_address_addr (irel, internal_relocs, irelend,
11319                                          checked_types[i], laddr);
11320           if (cond_irel != irelend)
11321             {
11322               if (*seq_len == 0
11323                   && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11324                 {
11325                   /* If the branch instruction is 2 byte, it cannot remove
11326                      directly.  Only convert it to nop16 and remove it after
11327                      checking alignment issue.  */
11328                   insn16 = NDS32_NOP16;
11329                   bfd_putb16 (insn16, contents + laddr);
11330                   cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11331                 }
11332               else
11333                 cond_irel->r_info =
11334                   ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
11335             }
11336         }
11337     }
11338   else
11339     {
11340       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11341                                    R_NDS32_LONGJUMP5);
11342     }
11343
11344   return TRUE;
11345 }
11346
11347 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section.  */
11348
11349 static bfd_boolean
11350 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11351                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11352                            int *seq_len, bfd_byte *contents,
11353                            Elf_Internal_Sym *isymbuf,
11354                            Elf_Internal_Shdr *symtab_hdr)
11355 {
11356   /* There are 2 variations for LONGJUMP5
11357      case 2-4;  1st insn convertible, 16-bit on.
11358      movi55  ta, imm11          ; LONGJUMP7/INSN16
11359      beq     rt, ta, label      ; 15_PCREL
11360
11361      case 4-4; 1st insn not convertible
11362      movi55  ta, imm11          ; LONGJUMP7/INSN16
11363      beq     rt, ta, label      ; 15_PCREL  */
11364
11365   bfd_vma laddr;
11366   Elf_Internal_Rela *cond_irel,  *irelend, *insn_irel;
11367   bfd_signed_vma foff;
11368   uint32_t insn, re_insn = 0;
11369   uint16_t insn16;
11370   uint32_t imm11;
11371
11372   irelend = internal_relocs + sec->reloc_count;
11373   laddr = irel->r_offset;
11374
11375   /* Get the reloc for the address from which the register is
11376      being loaded.  This reloc will tell us which function is
11377      actually being called.  */
11378
11379   cond_irel =
11380     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11381                                  R_NDS32_15_PCREL_RELA, irel->r_addend);
11382   if (cond_irel == irelend)
11383     {
11384       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
11385                           (uint64_t) irel->r_offset);
11386       return FALSE;
11387     }
11388
11389   /* Get the value of the symbol referred to by the reloc.  */
11390   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11391
11392   if (foff == 0
11393       || foff < -CONSERVATIVE_8BIT_S1
11394       || foff >= CONSERVATIVE_8BIT_S1)
11395     return FALSE;
11396
11397   /* Get the first instruction for its size.  */
11398   insn = bfd_getb32 (contents + laddr);
11399   if (insn & 0x80000000)
11400     {
11401       *seq_len = 0;
11402       /* Get the immediate from movi55.  */
11403       imm11 = N16_IMM5S (insn >> 16);
11404     }
11405   else
11406     {
11407       /* Get the immediate from movi.  */
11408       imm11 = N32_IMM20S (insn);
11409     }
11410
11411   /* Get the branch instruction.  */
11412   insn = bfd_getb32 (contents + irel->r_addend);
11413   /* Convert instruction to BR3.  */
11414   if ((insn >> 14) & 0x1)
11415     re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
11416   else
11417     re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
11418
11419   bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11420
11421   /* Set all relocations.  */
11422   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11423                                     R_NDS32_WORD_9_PCREL_RELA);
11424
11425   /* Clean relocations.  */
11426   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11427   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11428                                            R_NDS32_INSN16, irel->r_offset);
11429   if (insn_irel != irelend)
11430     {
11431       if (*seq_len == 0)
11432         {
11433           /* If the first insntruction is 16bit, convert it to nop16.  */
11434           insn16 = NDS32_NOP16;
11435           bfd_putb16 (insn16, contents + laddr);
11436           insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11437         }
11438       else
11439         cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11440                                           R_NDS32_NONE);
11441     }
11442   *insn_len = 0;
11443
11444   return TRUE;
11445 }
11446
11447 /* We figure out and reassign the best gp value in nds32_elf_final_sda_base
11448    for each relax round. But the gp may changed dramatically and then cause
11449    the truncated to fit errors for the the converted gp instructions.
11450    Therefore, we must reserve the minimum but safe enough size to prevent it.  */
11451
11452 static bfd_boolean
11453 nds32_elf_relax_guard (bfd_vma *access_addr, bfd_vma local_sda, asection *sec,
11454                        Elf_Internal_Rela *irel, bfd_boolean *again,
11455                        bfd_boolean init,
11456                        struct elf_nds32_link_hash_table *table,
11457                        Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
11458
11459 {
11460   int offset_to_gp;
11461   static bfd_boolean sec_pass = FALSE;
11462   static asection *first_sec = NULL, *sym_sec;
11463   /* Record the number of instructions which may be removed.  */
11464   static int count = 0, record_count;
11465   Elf_Internal_Sym *isym;
11466   struct elf_link_hash_entry *h = NULL;
11467   int indx;
11468   unsigned long r_symndx;
11469   bfd *abfd = sec->owner;
11470   static bfd_vma record_sda = 0;
11471   int sda_offset = 0;
11472
11473   /* Force doing relaxation when hyper-relax is high.  */
11474   if (table->hyper_relax == 2)
11475     return TRUE;
11476
11477   /* Do not relax the load/store patterns for the first
11478      relax round.  */
11479   if (init)
11480     {
11481       if (!first_sec)
11482         first_sec = sec;
11483       else if (first_sec == sec)
11484         {
11485           record_count = count;
11486           count = 0;
11487           sec_pass = TRUE;
11488         }
11489
11490       if (!sec_pass)
11491         *again = TRUE;
11492
11493       return TRUE;
11494     }
11495
11496   /* Generally, _SDA_BASE_ is fixed or smaller. But the large
11497      DATA_SEGMENT_ALIGN size in the linker script may make it
11498      get even bigger.  */
11499   if (record_sda == 0)
11500     record_sda = local_sda;
11501   else if (local_sda > record_sda)
11502     sda_offset = local_sda - record_sda;
11503
11504   /* Assume the instruction will be removed in the best case.  */
11505   count++;
11506
11507   /* We record the offset to gp for each symbol, and then check
11508      if it is changed dramatically after relaxing.
11509      (global symbol): elf32_nds32_hash_entry (h)->offset_to_gp
11510      (local symbol) : elf32_nds32_local_gp_offset (abfd)[r_symndx].  */
11511   r_symndx = ELF32_R_SYM (irel->r_info);
11512   if (r_symndx >= symtab_hdr->sh_info)
11513     {
11514       /* Global symbols.  */
11515       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11516       h = elf_sym_hashes (abfd)[indx];
11517       sym_sec = h->root.u.def.section;
11518       if (NDS32_GUARD_SEC_P (sym_sec->flags)
11519           || bfd_is_abs_section (sym_sec))
11520         {
11521           /* Forbid doing relaxation when hyper-relax is low.  */
11522           if (table->hyper_relax == 0)
11523             return FALSE;
11524
11525           offset_to_gp = *access_addr - local_sda;
11526           if (elf32_nds32_hash_entry (h)->offset_to_gp == 0)
11527             elf32_nds32_hash_entry (h)->offset_to_gp = offset_to_gp;
11528           else if (abs (elf32_nds32_hash_entry (h)->offset_to_gp)
11529                    < abs (offset_to_gp) - sda_offset)
11530             {
11531               /* This may cause the error, so we reserve the
11532                  safe enough size for relaxing.  */
11533               if (*access_addr >= local_sda)
11534                 *access_addr += (record_count * 4);
11535               else
11536                 *access_addr -= (record_count * 4);
11537             }
11538           return sec_pass;
11539         }
11540     }
11541   else
11542     {
11543       /* Local symbols.  */
11544       if (!elf32_nds32_allocate_local_sym_info (abfd))
11545         return FALSE;
11546       isym = isymbuf + r_symndx;
11547
11548       sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
11549       if (NDS32_GUARD_SEC_P (sym_sec->flags))
11550         {
11551           /* Forbid doing relaxation when hyper-relax is low.  */
11552           if (table->hyper_relax == 0)
11553             return FALSE;
11554
11555           offset_to_gp = *access_addr - local_sda;
11556           if (elf32_nds32_local_gp_offset (abfd)[r_symndx] == 0)
11557             elf32_nds32_local_gp_offset (abfd)[r_symndx] = offset_to_gp;
11558           else if (abs (elf32_nds32_local_gp_offset (abfd)[r_symndx])
11559                    < abs (offset_to_gp) - sda_offset)
11560             {
11561               /* This may cause the error, so we reserve the
11562                  safe enough size for relaxing.  */
11563               if (*access_addr >= local_sda)
11564                 *access_addr += (record_count * 4);
11565               else
11566                 *access_addr -= (record_count * 4);
11567             }
11568           return sec_pass;
11569         }
11570     }
11571
11572   return TRUE;
11573 }
11574
11575 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
11576
11577 /* Relax LOADSTORE relocation for nds32_elf_relax_section.  */
11578
11579 static bfd_boolean
11580 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
11581                            asection *sec, Elf_Internal_Rela *irel,
11582                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11583                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11584                            Elf_Internal_Shdr *symtab_hdr, int load_store_relax,
11585                            struct elf_nds32_link_hash_table *table)
11586 {
11587   int eliminate_sethi = 0, range_type;
11588   unsigned int i;
11589   bfd_vma local_sda, laddr;
11590   int seq_len;  /* Original length of instruction sequence.  */
11591   uint32_t insn;
11592   Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
11593   bfd_vma access_addr = 0;
11594   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11595   struct elf_link_hash_entry *h = NULL;
11596   int indx;
11597   enum elf_nds32_reloc_type checked_types[] =
11598     { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
11599       R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
11600       R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
11601       R_NDS32_TLS_LE_HI20
11602     };
11603
11604   irelend = internal_relocs + sec->reloc_count;
11605   seq_len = GET_SEQ_LEN (irel->r_addend);
11606   laddr = irel->r_offset;
11607   *insn_len = seq_len;
11608
11609   /* Get the high part relocation.  */
11610   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11611     {
11612       hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11613                                                checked_types[i], laddr);
11614       if (hi_irelfn != irelend)
11615         break;
11616     }
11617
11618   if (hi_irelfn == irelend)
11619     {
11620       /* Not R_NDS32_HI20_RELA.  */
11621       if (i != 0)
11622         _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
11623                             (uint64_t) irel->r_offset);
11624       return FALSE;
11625     }
11626
11627   range_type = GET_LOADSTORE_RANGE (irel->r_addend);
11628   nds32_elf_final_sda_base (sec->output_section->owner,
11629                             link_info, &local_sda, FALSE);
11630
11631   switch (ELF32_R_TYPE (hi_irelfn->r_info))
11632     {
11633     case R_NDS32_HI20_RELA:
11634       insn = bfd_getb32 (contents + laddr);
11635       access_addr =
11636         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
11637
11638       if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
11639         {
11640           indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
11641           h = elf_sym_hashes (abfd)[indx];
11642         }
11643
11644       /* Try movi.  */
11645       if (range_type == NDS32_LOADSTORE_IMM
11646           && access_addr < CONSERVATIVE_20BIT
11647           && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11648         {
11649           eliminate_sethi = 1;
11650           break;
11651         }
11652
11653       if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11654         {
11655           eliminate_sethi = 1;
11656           break;
11657         }
11658       else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, hi_irelfn,
11659                                        NULL, FALSE, table, isymbuf, symtab_hdr))
11660         return FALSE;
11661
11662       if (!load_store_relax)
11663         return FALSE;
11664
11665       /* Case for set gp register.  */
11666       if (N32_RT5 (insn) == REG_GP)
11667         return FALSE;
11668
11669       if (range_type == NDS32_LOADSTORE_FLOAT_S
11670           || range_type == NDS32_LOADSTORE_FLOAT_D)
11671         {
11672           range_l = sdata_range[0][0];
11673           range_h = sdata_range[0][1];
11674         }
11675       else
11676         {
11677           range_l = sdata_range[1][0];
11678           range_h = sdata_range[1][1];
11679         }
11680       break;
11681
11682     default:
11683       return FALSE;
11684     }
11685
11686   /* Delete sethi instruction.  */
11687   if (eliminate_sethi == 1
11688       || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
11689       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11690     {
11691       hi_irelfn->r_info =
11692         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
11693       irel->r_info =
11694         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11695       *insn_len = 0;
11696       return TRUE;
11697     }
11698
11699   return FALSE;
11700 }
11701
11702 /* Relax LO12 relocation for nds32_elf_relax_section.  */
11703
11704 static void
11705 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
11706                       asection *sec, Elf_Internal_Rela *irel,
11707                       Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
11708                       Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
11709                       struct elf_nds32_link_hash_table *table)
11710 {
11711   uint32_t insn;
11712   bfd_vma local_sda, laddr;
11713   unsigned long reloc;
11714   bfd_vma access_addr;
11715   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11716   Elf_Internal_Rela *irelfn = NULL, *irelend;
11717   struct elf_link_hash_entry *h = NULL;
11718   int indx;
11719
11720   /* For SDA base relative relaxation.  */
11721   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11722                             &local_sda, FALSE);
11723
11724   irelend = internal_relocs + sec->reloc_count;
11725   laddr = irel->r_offset;
11726   insn = bfd_getb32 (contents + laddr);
11727
11728   if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
11729     return;
11730
11731   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11732
11733   if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
11734     {
11735       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11736       h = elf_sym_hashes (abfd)[indx];
11737     }
11738
11739   /* Try movi.  */
11740   if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
11741       && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11742     {
11743       reloc = R_NDS32_20_RELA;
11744       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11745       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11746       bfd_putb32 (insn, contents + laddr);
11747     }
11748   else
11749     {
11750       if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11751         {
11752           /* Fall through.  */
11753         }
11754       else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, irel, NULL,
11755                                        FALSE, table, isymbuf, symtab_hdr))
11756         return;
11757
11758       range_l = sdata_range[1][0];
11759       range_h = sdata_range[1][1];
11760       switch (ELF32_R_TYPE (irel->r_info))
11761         {
11762         case R_NDS32_LO12S0_RELA:
11763           reloc = R_NDS32_SDA19S0_RELA;
11764           break;
11765         case R_NDS32_LO12S1_RELA:
11766           reloc = R_NDS32_SDA18S1_RELA;
11767           break;
11768         case R_NDS32_LO12S2_RELA:
11769           reloc = R_NDS32_SDA17S2_RELA;
11770           break;
11771         case R_NDS32_LO12S2_DP_RELA:
11772           range_l = sdata_range[0][0];
11773           range_h = sdata_range[0][1];
11774           reloc = R_NDS32_SDA12S2_DP_RELA;
11775           break;
11776         case R_NDS32_LO12S2_SP_RELA:
11777           range_l = sdata_range[0][0];
11778           range_h = sdata_range[0][1];
11779           reloc = R_NDS32_SDA12S2_SP_RELA;
11780           break;
11781         default:
11782           return;
11783         }
11784
11785       /* There are range_h and range_l because linker has to promise
11786          all sections move cross one page together.  */
11787       if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11788           || (local_sda > access_addr && (local_sda - access_addr) <= range_l)
11789           || (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0))
11790         {
11791           if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11792             {
11793               /* Maybe we should add R_NDS32_INSN16 reloc type here
11794                  or manually do some optimization.  sethi can't be
11795                  eliminated when updating $gp so the relative ori
11796                  needs to be preserved.  */
11797               return;
11798             }
11799           if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11800                                         &insn))
11801             return;
11802           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11803           bfd_putb32 (insn, contents + laddr);
11804
11805           irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11806                                            R_NDS32_INSN16);
11807           /* SDA17 must keep INSN16 for converting fp_as_gp.  */
11808           if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11809             irelfn->r_info =
11810               ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11811
11812         }
11813     }
11814   return;
11815 }
11816
11817 /* Relax PTR relocation for nds32_elf_relax_section.  */
11818
11819 static bfd_boolean
11820 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11821                      Elf_Internal_Rela *internal_relocs, int *insn_len,
11822                      int *seq_len, bfd_byte *contents)
11823 {
11824   Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11825
11826   irelend = internal_relocs + sec->reloc_count;
11827
11828   re_irel =
11829     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11830                                  R_NDS32_PTR_RESOLVED, irel->r_addend);
11831
11832   if (re_irel == irelend)
11833     {
11834       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11835                           (uint64_t) irel->r_offset);
11836       return FALSE;
11837     }
11838
11839   if (re_irel->r_addend != 1)
11840     return FALSE;
11841
11842   /* Pointed target is relaxed and no longer needs this void *,
11843      change the type to NONE.  */
11844   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11845
11846   /* Find PTR_COUNT to decide remove it or not.  If PTR_COUNT does
11847      not exist, it means only count 1 and remove it directly.  */
11848   /* TODO: I hope we can obsolate R_NDS32_COUNT in the future.  */
11849   count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11850                                        R_NDS32_PTR_COUNT);
11851   ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11852                                      R_NDS32_PTR);
11853   if (count_irel != irelend)
11854     {
11855       if (--count_irel->r_addend > 0)
11856         return FALSE;
11857     }
11858
11859   if (ptr_irel != irelend)
11860     return FALSE;
11861
11862   /* If the PTR_COUNT is already 0, remove current instruction.  */
11863   *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11864   *insn_len = 0;
11865   return TRUE;
11866 }
11867
11868 /* Relax LWC relocation for nds32_elf_relax_section.  */
11869
11870 static void
11871 nds32_elf_relax_flsi (struct bfd_link_info *link_info, bfd *abfd,
11872                       asection *sec, Elf_Internal_Rela *irel,
11873                       Elf_Internal_Rela *internal_relocs,
11874                       bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11875                       Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11876 {
11877   /* Pattern:
11878      sethi    ra, hi20(symbol)      ; HI20/LOADSTORE
11879      ori      ra, ra, lo12(symbol)  ; LO12S0/PTR/PTR/.../INSN16
11880      flsi     fsa, [ra + offset1]   ; LSI/PTR_RESOLVED/INSN16
11881      flsi     fsb, [ra + offset2]   ; LSI/PTR_RESOLVED/INSN16
11882      ...  */
11883
11884   uint32_t insn;
11885   bfd_vma local_sda, laddr;
11886   unsigned long reloc;
11887   bfd_vma access_addr, flsi_offset;
11888   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11889   Elf_Internal_Rela *irelend, *re_irel;
11890   unsigned int opcode;
11891
11892   irelend = internal_relocs + sec->reloc_count;
11893   laddr = irel->r_offset;
11894   insn = bfd_getb32 (contents + laddr);
11895
11896   if ((insn & 0x80000000) || !is_sda_access_insn (insn))
11897     return;
11898
11899   /* Can not do relaxation for bi format.  */
11900   if ((insn & 0x1000))
11901     return;
11902
11903   /* Only deal with flsi, fssi, fldi, fsdi, so far.  */
11904   opcode = N32_OP6 (insn);
11905   if ((opcode == N32_OP6_LWC) || (opcode == N32_OP6_SWC))
11906     reloc = R_NDS32_SDA12S2_SP_RELA;
11907   else if ((opcode == N32_OP6_LDC) || (opcode == N32_OP6_SDC))
11908     reloc = R_NDS32_SDA12S2_DP_RELA;
11909   else
11910     return;
11911
11912   re_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11913                                     R_NDS32_PTR_RESOLVED);
11914   if (re_irel == irelend)
11915     {
11916       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LSI",
11917                           (uint64_t) irel->r_offset);
11918       return;
11919     }
11920
11921   /* For SDA base relative relaxation.  */
11922   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11923                             &local_sda, FALSE);
11924   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11925   flsi_offset = (insn & 0xfff) << 2;
11926   access_addr += flsi_offset;
11927   range_l = sdata_range[0][0];
11928   range_h = sdata_range[0][1];
11929
11930   if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11931       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11932     {
11933       /* Turn flsi instruction into sda access format.  */
11934       insn = (insn & 0x7ff07000) | (REG_GP << 15);
11935
11936       /* Add relocation type to flsi.  */
11937       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11938       irel->r_addend += flsi_offset;
11939       bfd_putb32 (insn, contents + re_irel->r_offset);
11940
11941       re_irel->r_addend |= 1;
11942       *again = TRUE;
11943     }
11944 }
11945
11946 static bfd_boolean
11947 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11948                           Elf_Internal_Rela *internal_relocs,
11949                           bfd_byte *contents,
11950                           nds32_elf_blank_t **relax_blank_list,
11951                           int optimize, int opt_size)
11952 {
11953   /* This code block is used to adjust 4-byte alignment by relax a pair
11954      of instruction a time.
11955
11956      It recognizes three types of relocations.
11957      1. R_NDS32_LABEL - a alignment.
11958      2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11959      3. is_16bit_NOP () - remove a 16-bit instruction.  */
11960
11961   /* TODO: It seems currently implementation only support 4-byte alignment.
11962      We should handle any-alignment.  */
11963
11964   Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11965   Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11966   Elf_Internal_Rela rel_temp;
11967   Elf_Internal_Rela *irelend;
11968   bfd_vma address;
11969   uint16_t insn16;
11970
11971   /* Checking for branch relaxation relies on the relocations to
11972      be sorted on 'r_offset'.  This is not guaranteed so we must sort.  */
11973   nds32_insertion_sort (internal_relocs, sec->reloc_count,
11974                         sizeof (Elf_Internal_Rela), compar_reloc);
11975
11976   irelend = internal_relocs + sec->reloc_count;
11977
11978   /* Force R_NDS32_LABEL before R_NDS32_INSN16.  */
11979   /* FIXME: Can we generate the right order in assembler?
11980      So we don't have to swapping them here.  */
11981
11982   for (label_rel = internal_relocs, insn_rel = internal_relocs;
11983        label_rel < irelend; label_rel++)
11984     {
11985       if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11986         continue;
11987
11988       /* Find the first reloc has the same offset with label_rel.  */
11989       while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11990         insn_rel++;
11991
11992       for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11993            insn_rel++)
11994         /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11995            address.  */
11996         if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11997           break;
11998
11999       if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
12000           && insn_rel < label_rel)
12001         {
12002           /* Swap the two reloc if the R_NDS32_INSN16 is
12003              before R_NDS32_LABEL.  */
12004           memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
12005           memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
12006           memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
12007         }
12008     }
12009
12010   label_rel = NULL;
12011   insn_rel = NULL;
12012   /* If there were a sequence of R_NDS32_LABEL end up with .align 2
12013      or higher, remove other R_NDS32_LABEL with lower alignment.
12014      If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
12015      then the R_NDS32_LABEL sequence is broke.  */
12016   for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
12017     {
12018       if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
12019         {
12020           if (label_rel == NULL)
12021             {
12022               if (tmp_rel->r_addend < 2)
12023                 label_rel = tmp_rel;
12024               continue;
12025             }
12026           else if (tmp_rel->r_addend > 1)
12027             {
12028               /* Remove all LABEL relocation from label_rel to tmp_rel
12029                  including relocations with same offset as tmp_rel.  */
12030               for (tmp2_rel = label_rel; tmp2_rel < tmp_rel; tmp2_rel++)
12031                 {
12032                   if (tmp2_rel->r_offset == tmp_rel->r_offset)
12033                     break;
12034
12035                   if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
12036                       && tmp2_rel->r_addend < 2)
12037                     tmp2_rel->r_info =
12038                       ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
12039                                     R_NDS32_NONE);
12040                 }
12041               label_rel = NULL;
12042             }
12043         }
12044       else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
12045         {
12046           /* A new INSN16 which can be converted, so clear label_rel.  */
12047           if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
12048                                    irelend, &insn16)
12049               || is_16bit_NOP (abfd, sec, tmp_rel))
12050             label_rel = NULL;
12051         }
12052     }
12053
12054   label_rel = NULL;
12055   insn_rel = NULL;
12056   /* Optimized for speed and nothing has not been relaxed.
12057      It's time to align labels.
12058      We may convert a 16-bit instruction right before a label to
12059      32-bit, in order to align the label if necessary
12060      all reloc entries has been sorted by r_offset.  */
12061   for (irel = internal_relocs;
12062        irel < irelend && irel->r_offset < sec->size; irel++)
12063     {
12064       if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
12065           && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
12066         continue;
12067
12068       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
12069         {
12070           /* A new INSN16 found, resize the old one.  */
12071           if (is_convert_32_to_16
12072               (abfd, sec, irel, internal_relocs, irelend, &insn16)
12073               || is_16bit_NOP (abfd, sec, irel))
12074             {
12075               if (insn_rel)
12076                 {
12077                   /* Previous INSN16 reloc exists, reduce its
12078                      size to 16-bit.  */
12079                   if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12080                                            irelend, &insn16))
12081                     {
12082                       nds32_elf_write_16 (abfd, contents, insn_rel,
12083                                           internal_relocs, irelend, insn16);
12084
12085                       if (!insert_nds32_elf_blank_recalc_total
12086                           (relax_blank_list, insn_rel->r_offset + 2, 2))
12087                         return FALSE;
12088                     }
12089                   else if (is_16bit_NOP (abfd, sec, insn_rel))
12090                     {
12091                       if (!insert_nds32_elf_blank_recalc_total
12092                           (relax_blank_list, insn_rel->r_offset, 2))
12093                         return FALSE;
12094                     }
12095                   insn_rel->r_info =
12096                     ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
12097                 }
12098               /* Save the new one for later use.  */
12099               insn_rel = irel;
12100             }
12101           else
12102             irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
12103                                          R_NDS32_NONE);
12104         }
12105       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
12106         {
12107           /* Search for label.  */
12108           int force_relax = 0;
12109
12110           /* Label on 16-bit instruction or optimization
12111              needless, just reset this reloc.  */
12112           insn16 = bfd_getb16 (contents + irel->r_offset);
12113           if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
12114             {
12115               irel->r_info =
12116                 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
12117               continue;
12118             }
12119
12120           address =
12121             irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
12122                                                         irel->r_offset, 1);
12123
12124           if (!insn_rel)
12125             {
12126               /* Check if there is case which can not be aligned.  */
12127               if (irel->r_addend == 2 && address & 0x2)
12128                 return FALSE;
12129               continue;
12130             }
12131
12132           /* Try to align this label.  */
12133
12134           if ((irel->r_addend & 0x1f) < 2)
12135             {
12136               /* Check if there is a INSN16 at the same address.
12137                  Label_rel always seats before insn_rel after
12138                  our sort.  */
12139
12140               /* Search for INSN16 at LABEL location.  If INSN16 is at
12141                  same location and this LABEL alignment is lower than 2,
12142                  the INSN16 can be converted to 2-byte.  */
12143               for (tmp_rel = irel;
12144                    tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
12145                    tmp_rel++)
12146                 {
12147                   if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
12148                       && (is_convert_32_to_16
12149                           (abfd, sec, tmp_rel, internal_relocs,
12150                            irelend, &insn16)
12151                           || is_16bit_NOP (abfd, sec, tmp_rel)))
12152                     {
12153                       force_relax = 1;
12154                       break;
12155                     }
12156                 }
12157             }
12158
12159           if (force_relax || irel->r_addend == 1 || address & 0x2)
12160             {
12161               /* Label not aligned.  */
12162               /* Previous reloc exists, reduce its size to 16-bit.  */
12163               if (is_convert_32_to_16 (abfd, sec, insn_rel,
12164                                        internal_relocs, irelend, &insn16))
12165                 {
12166                   nds32_elf_write_16 (abfd, contents, insn_rel,
12167                                       internal_relocs, irelend, insn16);
12168
12169                   if (!insert_nds32_elf_blank_recalc_total
12170                       (relax_blank_list, insn_rel->r_offset + 2, 2))
12171                     return FALSE;
12172                 }
12173               else if (is_16bit_NOP (abfd, sec, insn_rel))
12174                 {
12175                   if (!insert_nds32_elf_blank_recalc_total
12176                       (relax_blank_list, insn_rel->r_offset, 2))
12177                     return FALSE;
12178                 }
12179
12180             }
12181           /* INSN16 reloc is used.  */
12182           insn_rel = NULL;
12183         }
12184     }
12185
12186   address =
12187     sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
12188   if (insn_rel && (address & 0x2 || opt_size))
12189     {
12190       if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12191                                irelend, &insn16))
12192         {
12193           nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
12194                               irelend, insn16);
12195           if (!insert_nds32_elf_blank_recalc_total
12196               (relax_blank_list, insn_rel->r_offset + 2, 2))
12197             return FALSE;
12198           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12199                                            R_NDS32_NONE);
12200         }
12201       else if (is_16bit_NOP (abfd, sec, insn_rel))
12202         {
12203           if (!insert_nds32_elf_blank_recalc_total
12204               (relax_blank_list, insn_rel->r_offset, 2))
12205             return FALSE;
12206           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12207                                            R_NDS32_NONE);
12208         }
12209     }
12210   insn_rel = NULL;
12211   return TRUE;
12212 }
12213
12214 static bfd_boolean
12215 nds32_elf_relax_section (bfd *abfd, asection *sec,
12216                          struct bfd_link_info *link_info, bfd_boolean *again)
12217 {
12218   nds32_elf_blank_t *relax_blank_list = NULL;
12219   Elf_Internal_Shdr *symtab_hdr;
12220   Elf_Internal_Rela *internal_relocs;
12221   Elf_Internal_Rela *irel;
12222   Elf_Internal_Rela *irelend;
12223   Elf_Internal_Sym *isymbuf = NULL;
12224   bfd_byte *contents = NULL;
12225   bfd_boolean result = TRUE;
12226   int optimize = 0;
12227   int opt_size = 0;
12228   uint32_t insn;
12229   uint16_t insn16;
12230
12231   /* Target dependnet option.  */
12232   struct elf_nds32_link_hash_table *table;
12233   int load_store_relax;
12234
12235   relax_blank_list = NULL;
12236
12237   *again = FALSE;
12238
12239   /* Nothing to do for
12240    * relocatable link or
12241    * non-relocatable section or
12242    * non-code section or
12243    * empty content or
12244    * no reloc entry.  */
12245   if (bfd_link_relocatable (link_info)
12246       || (sec->flags & SEC_RELOC) == 0
12247       || (sec->flags & SEC_EXCLUDE) != 0
12248       || (sec->flags & SEC_CODE) == 0
12249       || sec->size == 0
12250       || sec->reloc_count == 0)
12251     return TRUE;
12252
12253   /* 09.12.11 Workaround.  */
12254   /*  We have to adjust align for R_NDS32_LABEL if needed.
12255       The adjust approach only can fix 2-byte align once.  */
12256   if (sec->alignment_power > 2)
12257     return TRUE;
12258
12259   /* Do TLS model conversion once at first.  */
12260   nds32_elf_unify_tls_model (abfd, sec, contents, link_info);
12261
12262   /* The optimization type to do.  */
12263
12264   table = nds32_elf_hash_table (link_info);
12265
12266   /* Save the first section for abs symbol relaxation.
12267      This is used for checking gp relaxation in the
12268      nds32_elf_relax_loadstore and nds32_elf_relax_lo12.  */
12269   nds32_elf_relax_guard (NULL, 0, sec, NULL, again, TRUE,
12270                          table, NULL, NULL);
12271
12272   /* The begining of general relaxation.  */
12273
12274   if (is_SDA_BASE_set == 0)
12275     {
12276       bfd_vma gp;
12277       is_SDA_BASE_set = 1;
12278       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12279                                 &gp, FALSE);
12280       relax_range_measurement (abfd);
12281     }
12282
12283   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12284   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
12285   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12286                                                TRUE /* keep_memory */);
12287   if (internal_relocs == NULL)
12288     goto error_return;
12289
12290   irelend = internal_relocs + sec->reloc_count;
12291   irel = find_relocs_at_address (internal_relocs, internal_relocs,
12292                                  irelend, R_NDS32_RELAX_ENTRY);
12293
12294   if (irel == irelend)
12295     return TRUE;
12296
12297   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12298     {
12299       if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12300         return TRUE;
12301
12302       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12303         optimize = 1;
12304
12305       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12306         opt_size = 1;
12307     }
12308
12309   load_store_relax = table->load_store_relax;
12310
12311   /* Get symbol table and section content.  */
12312   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12313       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12314     goto error_return;
12315
12316   /* Do relax loop only when finalize is not done.
12317      Take care of relaxable relocs except INSN16.  */
12318   for (irel = internal_relocs; irel < irelend; irel++)
12319     {
12320       int seq_len;              /* Original length of instruction sequence.  */
12321       int insn_len = 0;         /* Final length of instruction sequence.  */
12322       bfd_boolean removed;
12323
12324       insn = 0;
12325       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12326           && (irel->r_addend & 0x1f) >= 2)
12327         optimize = 1;
12328
12329       /* Relocation Types
12330          R_NDS32_LONGCALL1      53
12331          R_NDS32_LONGCALL2      54
12332          R_NDS32_LONGCALL3      55
12333          R_NDS32_LONGJUMP1      56
12334          R_NDS32_LONGJUMP2      57
12335          R_NDS32_LONGJUMP3      58
12336          R_NDS32_LOADSTORE      59  */
12337       if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12338           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12339         seq_len = GET_SEQ_LEN (irel->r_addend);
12340
12341       /* Relocation Types
12342          R_NDS32_LONGCALL4      107
12343          R_NDS32_LONGCALL5      108
12344          R_NDS32_LONGCALL6      109
12345          R_NDS32_LONGJUMP4      110
12346          R_NDS32_LONGJUMP5      111
12347          R_NDS32_LONGJUMP6      112
12348          R_NDS32_LONGJUMP7      113  */
12349       else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12350                && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12351         seq_len = 4;
12352
12353         /* Relocation Types
12354          R_NDS32_LO12S0_RELA            30
12355          R_NDS32_LO12S1_RELA            29
12356          R_NDS32_LO12S2_RELA            28
12357          R_NDS32_LO12S2_SP_RELA         71
12358          R_NDS32_LO12S2_DP_RELA         70
12359          R_NDS32_GOT_LO12               46
12360          R_NDS32_GOTOFF_LO12            50
12361          R_NDS32_PLTREL_LO12            65
12362          R_NDS32_PLT_GOTREL_LO12        67
12363          R_NDS32_17IFC_PCREL_RELA       96
12364          R_NDS32_GOT_SUFF               193
12365          R_NDS32_GOTOFF_SUFF            194
12366          R_NDS32_PLT_GOT_SUFF           195
12367          R_NDS32_MULCALL_SUFF           196
12368          R_NDS32_PTR                    197  */
12369       else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12370                 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12371                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12372                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12373                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12374                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12375                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12376                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12377                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12378                || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12379                    && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12380                || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12381                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12382                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12383                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS
12384                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LSI)
12385         seq_len = 0;
12386       else
12387         continue;
12388
12389       insn_len = seq_len;
12390       removed = FALSE;
12391
12392       switch (ELF32_R_TYPE (irel->r_info))
12393         {
12394         case R_NDS32_LONGCALL1:
12395           removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12396                                                &insn_len, contents, isymbuf,
12397                                                symtab_hdr);
12398           break;
12399         case R_NDS32_LONGCALL2:
12400           removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12401                                                &insn_len, contents, isymbuf,
12402                                                symtab_hdr);
12403           break;
12404         case R_NDS32_LONGCALL3:
12405           removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12406                                                &insn_len, contents, isymbuf,
12407                                                symtab_hdr);
12408           break;
12409         case R_NDS32_LONGJUMP1:
12410           removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12411                                                &insn_len, contents, isymbuf,
12412                                                symtab_hdr);
12413           break;
12414         case R_NDS32_LONGJUMP2:
12415           removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12416                                                &insn_len, contents, isymbuf,
12417                                                symtab_hdr);
12418           break;
12419         case R_NDS32_LONGJUMP3:
12420           removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12421                                                &insn_len, contents, isymbuf,
12422                                                symtab_hdr);
12423           break;
12424         case R_NDS32_LONGCALL4:
12425           removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12426                                                &insn_len, contents, isymbuf,
12427                                                symtab_hdr);
12428           break;
12429         case R_NDS32_LONGCALL5:
12430           removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12431                                                &insn_len, contents, isymbuf,
12432                                                symtab_hdr);
12433           break;
12434         case R_NDS32_LONGCALL6:
12435           removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12436                                                &insn_len, contents, isymbuf,
12437                                                symtab_hdr);
12438           break;
12439         case R_NDS32_LONGJUMP4:
12440           removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12441                                                &insn_len, contents, isymbuf,
12442                                                symtab_hdr);
12443           break;
12444         case R_NDS32_LONGJUMP5:
12445           removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12446                                                &insn_len, &seq_len, contents,
12447                                                isymbuf, symtab_hdr);
12448           break;
12449         case R_NDS32_LONGJUMP6:
12450           removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12451                                                &insn_len, &seq_len, contents,
12452                                                isymbuf, symtab_hdr);
12453           break;
12454         case R_NDS32_LONGJUMP7:
12455           removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12456                                                &insn_len, &seq_len, contents,
12457                                                isymbuf, symtab_hdr);
12458           break;
12459         case R_NDS32_LOADSTORE:
12460           removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12461                                                internal_relocs, &insn_len,
12462                                                contents, isymbuf, symtab_hdr,
12463                                                load_store_relax, table);
12464           break;
12465         case R_NDS32_LO12S0_RELA:
12466         case R_NDS32_LO12S1_RELA:
12467         case R_NDS32_LO12S2_RELA:
12468         case R_NDS32_LO12S2_DP_RELA:
12469         case R_NDS32_LO12S2_SP_RELA:
12470           /* Relax for low part.  */
12471           nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12472                                 contents, isymbuf, symtab_hdr, table);
12473
12474           /* It is impossible to delete blank, so just continue.  */
12475           continue;
12476         case R_NDS32_PTR:
12477           removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12478                                          &insn_len, &seq_len, contents);
12479           break;
12480         case R_NDS32_LSI:
12481           nds32_elf_relax_flsi (link_info, abfd, sec, irel, internal_relocs,
12482                                 contents, isymbuf, symtab_hdr, again);
12483           continue;
12484         case R_NDS32_GOT_LO12:
12485         case R_NDS32_GOTOFF_LO12:
12486         case R_NDS32_PLTREL_LO12:
12487         case R_NDS32_PLT_GOTREL_LO12:
12488         case R_NDS32_GOTPC_LO12:
12489         case R_NDS32_TLS_LE_LO12:
12490         case R_NDS32_TLS_LE_ADD:
12491         case R_NDS32_TLS_LE_LS:
12492         case R_NDS32_PLT_GOT_SUFF:
12493         case R_NDS32_GOT_SUFF:
12494         case R_NDS32_GOTOFF_SUFF:
12495           continue;
12496         default:
12497           continue;
12498         }
12499
12500       if (removed && seq_len - insn_len > 0)
12501         {
12502           if (!insert_nds32_elf_blank
12503               (&relax_blank_list, irel->r_offset + insn_len,
12504                seq_len - insn_len))
12505             goto error_return;
12506           *again = TRUE;
12507         }
12508     }
12509
12510   calc_nds32_blank_total (relax_blank_list);
12511
12512   if (table->relax_fp_as_gp)
12513     {
12514       if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12515                                  irelend, isymbuf))
12516         goto error_return;
12517
12518       if (!*again)
12519         {
12520           if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12521                                                irelend))
12522             goto error_return;
12523         }
12524     }
12525
12526   if (!*again)
12527     {
12528       if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12529                                      &relax_blank_list, optimize, opt_size))
12530         goto error_return;
12531     }
12532
12533   /* It doesn't matter optimize_for_space_no_align anymore.
12534        If object file is assembled with flag '-Os',
12535        the we don't adjust jump-destination on 4-byte boundary.  */
12536
12537   if (relax_blank_list)
12538     {
12539       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12540       relax_blank_list = NULL;
12541     }
12542
12543   if (!*again)
12544     {
12545       /* Closing the section, so we don't relax it anymore.  */
12546       bfd_vma sec_size_align;
12547       Elf_Internal_Rela *tmp_rel;
12548
12549       /* Pad to alignment boundary.  Only handle current section alignment.  */
12550       sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12551                        & ((-1U) << sec->alignment_power);
12552       if ((sec_size_align - sec->size) & 0x2)
12553         {
12554           insn16 = NDS32_NOP16;
12555           bfd_putb16 (insn16, contents + sec->size);
12556           sec->size += 2;
12557         }
12558
12559       while (sec_size_align != sec->size)
12560         {
12561           insn = NDS32_NOP32;
12562           bfd_putb32 (insn, contents + sec->size);
12563           sec->size += 4;
12564         }
12565
12566       tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12567                                         irelend, R_NDS32_RELAX_ENTRY);
12568       if (tmp_rel != irelend)
12569         tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12570
12571       clean_nds32_elf_blank ();
12572     }
12573
12574  finish:
12575   if (internal_relocs != NULL
12576       && elf_section_data (sec)->relocs != internal_relocs)
12577     free (internal_relocs);
12578
12579   if (contents != NULL
12580       && elf_section_data (sec)->this_hdr.contents != contents)
12581     free (contents);
12582
12583   if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12584     free (isymbuf);
12585
12586   return result;
12587
12588  error_return:
12589   result = FALSE;
12590   goto finish;
12591 }
12592
12593 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12594 {
12595   {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12596   {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12597   {NULL, 0, 0, 0, 0}
12598 };
12599
12600 static bfd_boolean
12601 nds32_elf_section_flags (const Elf_Internal_Shdr *hdr)
12602 {
12603   const char *name = hdr->bfd_section->name;
12604
12605   if (strncmp (name, ".sbss", 5) == 0
12606       || strncmp (name, ".sdata", 6) == 0)
12607     hdr->bfd_section->flags |= SEC_SMALL_DATA;
12608
12609   return TRUE;
12610 }
12611
12612 static bfd_boolean
12613 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12614                             struct bfd_link_info *info,
12615                             void *finfo ATTRIBUTE_UNUSED,
12616                             bfd_boolean (*func) (void *, const char *,
12617                                                  Elf_Internal_Sym *,
12618                                                  asection *,
12619                                                  struct elf_link_hash_entry *)
12620                             ATTRIBUTE_UNUSED)
12621 {
12622   FILE *sym_ld_script = NULL;
12623   struct elf_nds32_link_hash_table *table;
12624
12625   table = nds32_elf_hash_table (info);
12626   sym_ld_script = table->sym_ld_script;
12627
12628   if (check_start_export_sym)
12629     fprintf (sym_ld_script, "}\n");
12630
12631   return TRUE;
12632 }
12633
12634 static enum elf_reloc_type_class
12635 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12636                             const asection *rel_sec ATTRIBUTE_UNUSED,
12637                             const Elf_Internal_Rela *rela)
12638 {
12639   switch ((int) ELF32_R_TYPE (rela->r_info))
12640     {
12641     case R_NDS32_RELATIVE:
12642       return reloc_class_relative;
12643     case R_NDS32_JMP_SLOT:
12644       return reloc_class_plt;
12645     case R_NDS32_COPY:
12646       return reloc_class_copy;
12647     default:
12648       return reloc_class_normal;
12649     }
12650 }
12651
12652 /* Put target dependent option into info hash table.  */
12653 void
12654 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12655                                    int relax_fp_as_gp,
12656                                    int eliminate_gc_relocs,
12657                                    FILE * sym_ld_script,
12658                                    int hyper_relax,
12659                                    int tls_desc_trampoline,
12660                                    int load_store_relax)
12661 {
12662   struct elf_nds32_link_hash_table *table;
12663
12664   table = nds32_elf_hash_table (link_info);
12665   if (table == NULL)
12666     return;
12667
12668   table->relax_fp_as_gp = relax_fp_as_gp;
12669   table->eliminate_gc_relocs = eliminate_gc_relocs;
12670   table->sym_ld_script = sym_ld_script;
12671   table->hyper_relax = hyper_relax;
12672   table->tls_desc_trampoline = tls_desc_trampoline;
12673   table ->load_store_relax = load_store_relax;
12674 }
12675 \f
12676
12677 /* These functions and data-structures are used for fp-as-gp
12678    optimization.  */
12679
12680 #define FAG_THRESHOLD   3       /* At least 3 gp-access.  */
12681 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12682    the read-only section and read-write section.  */
12683 #define FAG_WINDOW      (508 - 32)
12684
12685 /* An nds32_fag represent a gp-relative access.
12686    We find best fp-base by using a sliding window
12687    to find a base address which can cover most gp-access.  */
12688 struct nds32_fag
12689 {
12690   struct nds32_fag *next;       /* NULL-teminated linked list.  */
12691   bfd_vma addr;                 /* The address of this fag.  */
12692   Elf_Internal_Rela **relas;    /* The relocations associated with this fag.
12693                                    It is used for applying FP7U2_FLAG.  */
12694   int count;                    /* How many times this address is referred.
12695                                    There should be exactly `count' relocations
12696                                    in relas.  */
12697   int relas_capcity;            /* The buffer size of relas.
12698                                    We use an array instead of linked-list,
12699                                    and realloc is used to adjust buffer size.  */
12700 };
12701
12702 static void
12703 nds32_fag_init (struct nds32_fag *head)
12704 {
12705   memset (head, 0, sizeof (struct nds32_fag));
12706 }
12707
12708 static void
12709 nds32_fag_verify (struct nds32_fag *head)
12710 {
12711   struct nds32_fag *iter;
12712   struct nds32_fag *prev;
12713
12714   prev = NULL;
12715   iter = head->next;
12716   while (iter)
12717     {
12718       if (prev && prev->addr >= iter->addr)
12719         puts ("Bug in fp-as-gp insertion.");
12720       prev = iter;
12721       iter = iter->next;
12722     }
12723 }
12724
12725 /* Insert a fag in ascending order.
12726    If a fag of the same address already exists,
12727    they are chained by relas array.  */
12728
12729 static void
12730 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12731                   Elf_Internal_Rela * rel)
12732 {
12733   struct nds32_fag *iter;
12734   struct nds32_fag *new_fag;
12735   const int INIT_RELAS_CAP = 4;
12736
12737   for (iter = head;
12738        iter->next && iter->next->addr <= addr;
12739        iter = iter->next)
12740     /* Find somewhere to insert.  */ ;
12741
12742   /* `iter' will be equal to `head' if the list is empty.  */
12743   if (iter != head && iter->addr == addr)
12744     {
12745       /* The address exists in the list.
12746          Insert `rel' into relocation list, relas.  */
12747
12748       /* Check whether relas is big enough.  */
12749       if (iter->count >= iter->relas_capcity)
12750         {
12751           iter->relas_capcity *= 2;
12752           iter->relas = bfd_realloc
12753             (iter->relas, iter->relas_capcity * sizeof (void *));
12754         }
12755       iter->relas[iter->count++] = rel;
12756       return;
12757     }
12758
12759   /* This is a new address.  Create a fag node for it.  */
12760   new_fag = bfd_malloc (sizeof (struct nds32_fag));
12761   memset (new_fag, 0, sizeof (*new_fag));
12762   new_fag->addr = addr;
12763   new_fag->count = 1;
12764   new_fag->next = iter->next;
12765   new_fag->relas_capcity = INIT_RELAS_CAP;
12766   new_fag->relas = (Elf_Internal_Rela **)
12767     bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12768   new_fag->relas[0] = rel;
12769   iter->next = new_fag;
12770
12771   nds32_fag_verify (head);
12772 }
12773
12774 static void
12775 nds32_fag_free_list (struct nds32_fag *head)
12776 {
12777   struct nds32_fag *iter;
12778
12779   iter = head->next;
12780   while (iter)
12781     {
12782       struct nds32_fag *tmp = iter;
12783       iter = iter->next;
12784       free (tmp->relas);
12785       tmp->relas = NULL;
12786       free (tmp);
12787     }
12788 }
12789
12790 /* Find the best fp-base address.
12791    The relocation associated with that address is returned,
12792    so we can track the symbol instead of a fixed address.
12793
12794    When relaxation, the address of an datum may change,
12795    because a text section is shrinked, so the data section
12796    moves forward.  If the aligments of text and data section
12797    are different, their distance may change too.
12798    Therefore, tracking a fixed address is not appriate.  */
12799
12800 static int
12801 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12802 {
12803   struct nds32_fag *base;       /* First fag in the window.  */
12804   struct nds32_fag *last;       /* First fag outside the window.  */
12805   int accu = 0;                 /* Usage accumulation.  */
12806   struct nds32_fag *best;       /* Best fag.  */
12807   int baccu = 0;                /* Best accumulation.  */
12808
12809   /* Use first fag for initial, and find the last fag in the window.
12810
12811      In each iteration, we could simply subtract previous fag
12812      and accumulate following fags which are inside the window,
12813      untill we each the end.  */
12814
12815   if (head->next == NULL)
12816     {
12817       *bestpp = NULL;
12818       return 0;
12819     }
12820
12821   /* Initialize base.  */
12822   base = head->next;
12823   best = base;
12824   for (last = base;
12825        last && last->addr < base->addr + FAG_WINDOW;
12826        last = last->next)
12827     accu += last->count;
12828
12829   baccu = accu;
12830
12831   /* Record the best base in each iteration.  */
12832   while (base->next)
12833     {
12834       accu -= base->count;
12835       base = base->next;
12836       /* Account fags in window.  */
12837       for (/* Nothing.  */;
12838            last && last->addr < base->addr + FAG_WINDOW;
12839            last = last->next)
12840         accu += last->count;
12841
12842       /* A better fp-base?  */
12843       if (accu > baccu)
12844         {
12845           best = base;
12846           baccu = accu;
12847         }
12848     }
12849
12850   if (bestpp)
12851     *bestpp = best;
12852   return baccu;
12853 }
12854
12855 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12856    so we can convert it fo fp-relative access later.
12857    `best_fag' is the best fp-base.  Only those inside the window
12858    of best_fag is applied the flag.  */
12859
12860 static bfd_boolean
12861 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12862                       asection *sec, struct nds32_fag *best_fag,
12863                       Elf_Internal_Rela *internal_relocs,
12864                       Elf_Internal_Rela *irelend)
12865 {
12866   struct nds32_fag *ifag;
12867   bfd_vma best_fpbase, gp;
12868   bfd *output_bfd;
12869
12870   output_bfd = sec->output_section->owner;
12871   nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12872   best_fpbase = best_fag->addr;
12873
12874   if (best_fpbase > gp + sdata_range[1][1]
12875       || best_fpbase < gp - sdata_range[1][0])
12876     return FALSE;
12877
12878   /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12879      so we know they can be converted to lwi37.fp.   */
12880   for (ifag = best_fag;
12881        ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12882     {
12883       int i;
12884
12885       for (i = 0; i < ifag->count; i++)
12886         {
12887           Elf_Internal_Rela *insn16_rel;
12888           Elf_Internal_Rela *fag_rel;
12889
12890           fag_rel = ifag->relas[i];
12891
12892           /* Only if this is within the WINDOWS, FP7U2_FLAG
12893              is applied.  */
12894
12895           insn16_rel = find_relocs_at_address
12896             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12897
12898           if (insn16_rel != irelend)
12899             insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12900         }
12901     }
12902   return TRUE;
12903 }
12904
12905 /* Reset INSN16 to clean fp as gp.  */
12906
12907 static void
12908 nds32_fag_unmark_relax (struct nds32_fag *fag,
12909                         Elf_Internal_Rela *internal_relocs,
12910                         Elf_Internal_Rela *irelend)
12911 {
12912   struct nds32_fag *ifag;
12913   int i;
12914   Elf_Internal_Rela *insn16_rel;
12915   Elf_Internal_Rela *fag_rel;
12916
12917   for (ifag = fag; ifag; ifag = ifag->next)
12918     {
12919       for (i = 0; i < ifag->count; i++)
12920         {
12921           fag_rel = ifag->relas[i];
12922
12923           /* Restore the INSN16 relocation.  */
12924           insn16_rel = find_relocs_at_address
12925             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12926
12927           if (insn16_rel != irelend)
12928             insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12929         }
12930     }
12931 }
12932
12933 /* This is the main function of fp-as-gp optimization.
12934    It should be called by relax_section.  */
12935
12936 static bfd_boolean
12937 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12938                       bfd *abfd, asection *sec,
12939                       Elf_Internal_Rela *internal_relocs,
12940                       Elf_Internal_Rela *irelend,
12941                       Elf_Internal_Sym *isymbuf)
12942 {
12943   Elf_Internal_Rela *begin_rel = NULL;
12944   Elf_Internal_Rela *irel;
12945   struct nds32_fag fag_head;
12946   Elf_Internal_Shdr *symtab_hdr;
12947   bfd_byte *contents;
12948   bfd_boolean ifc_inside = FALSE;
12949
12950   /* FIXME: Can we bfd_elf_link_read_relocs for the relocs?  */
12951
12952   /* Per-function fp-base selection.
12953      1. Create a list for all the gp-relative access.
12954      2. Base on those gp-relative address,
12955         find a fp-base which can cover most access.
12956      3. Use the fp-base for fp-as-gp relaxation.
12957
12958      NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12959      we should
12960      1. delete the `la $fp, _FP_BASE_' instruction and
12961      2. not convert lwi.gp to lwi37.fp.
12962
12963      To delete the _FP_BASE_ instruction, we simply apply
12964      R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12965
12966      To suppress the conversion, we simply NOT to apply
12967      R_NDS32_INSN16_FP7U2_FLAG flag.  */
12968
12969   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12970
12971   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12972       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12973     return FALSE;
12974
12975   /* Check whether it is worth for fp-as-gp optimization,
12976      i.e., at least 3 gp-load.
12977
12978      Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12979      apply this optimization.  */
12980
12981   for (irel = internal_relocs; irel < irelend; irel++)
12982     {
12983       /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12984          One we enter the begin of the region, we track all the LW/ST
12985          instructions, so when we leave the region, we try to find
12986          the best fp-base address for those LW/ST instructions.  */
12987
12988       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12989           && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12990         {
12991           /* Begin of the region.  */
12992           if (begin_rel)
12993             /* xgettext:c-format */
12994             _bfd_error_handler (_("%pB: nested OMIT_FP in %pA"), abfd, sec);
12995
12996           begin_rel = irel;
12997           nds32_fag_init (&fag_head);
12998           ifc_inside = FALSE;
12999         }
13000       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13001                && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
13002         {
13003           int accu;
13004           struct nds32_fag *best_fag, *tmp_fag;
13005           int dist;
13006
13007           /* End of the region.
13008              Check whether it is worth to do fp-as-gp.  */
13009
13010           if (begin_rel == NULL)
13011             {
13012               /* xgettext:c-format */
13013               _bfd_error_handler (_("%pB: unmatched OMIT_FP in %pA"),
13014                                   abfd, sec);
13015               continue;
13016             }
13017
13018           accu = nds32_fag_find_base (&fag_head, &best_fag);
13019
13020           /* Clean FP7U2_FLAG because they may set ever.  */
13021           tmp_fag = fag_head.next;
13022           nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
13023
13024           /* Check if it is worth, and FP_BASE is near enough to SDA_BASE.  */
13025           if (accu < FAG_THRESHOLD
13026               || !nds32_fag_mark_relax (link_info, sec, best_fag,
13027                                         internal_relocs, irelend))
13028             {
13029               /* Not worth to do fp-as-gp.  */
13030               begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13031               begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13032               irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13033               irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13034               nds32_fag_free_list (&fag_head);
13035               begin_rel = NULL;
13036               continue;
13037             }
13038
13039           /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
13040              so we use it to record the distance to the reloction of best
13041              fp-base.  */
13042           dist = best_fag->relas[0] - begin_rel;
13043           BFD_ASSERT (dist > 0 && dist < 0xffffff);
13044           /* Use high 16 bits of addend to record the _FP_BASE_ matched
13045              relocation.  And get the base value when relocating.  */
13046           begin_rel->r_addend &= (0x1 << 16) - 1;
13047           begin_rel->r_addend |= dist << 16;
13048
13049           nds32_fag_free_list (&fag_head);
13050           begin_rel = NULL;
13051         }
13052
13053       if (begin_rel == NULL || ifc_inside)
13054         /* Skip if we are not in the region of fp-as-gp.  */
13055         continue;
13056
13057       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
13058           || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
13059         {
13060           bfd_vma addr;
13061           uint32_t insn;
13062
13063           /* A gp-relative access is found.  Insert it to the fag-list.  */
13064
13065           /* Rt is necessary an RT3, so it can be converted to lwi37.fp.  */
13066           insn = bfd_getb32 (contents + irel->r_offset);
13067           if (!N32_IS_RT3 (insn))
13068             continue;
13069
13070           addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
13071           nds32_fag_insert (&fag_head, addr, irel);
13072         }
13073       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
13074         {
13075           begin_rel = NULL;
13076         }
13077       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
13078                || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13079         {
13080           /* Suppress fp as gp when encounter ifc.  */
13081           ifc_inside = TRUE;
13082         }
13083     }
13084
13085   return TRUE;
13086 }
13087
13088 /* Remove unused `la $fp, _FD_BASE_' instruction.  */
13089
13090 static bfd_boolean
13091 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
13092                                 Elf_Internal_Rela *internal_relocs,
13093                                 Elf_Internal_Rela *irelend)
13094 {
13095   Elf_Internal_Rela *irel;
13096   Elf_Internal_Shdr *symtab_hdr;
13097   bfd_byte *contents = NULL;
13098   nds32_elf_blank_t *relax_blank_list = NULL;
13099   bfd_boolean result = TRUE;
13100   bfd_boolean unused_region = FALSE;
13101
13102   /*
13103      NOTE: Disable fp-as-gp if we encounter ifcall relocations:
13104        R_NDS32_17IFC_PCREL_RELA
13105        R_NDS32_10IFCU_PCREL_RELA.  */
13106
13107   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13108   nds32_get_section_contents (abfd, sec, &contents, TRUE);
13109
13110   for (irel = internal_relocs; irel < irelend; irel++)
13111     {
13112       /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
13113          we marked to in previous pass.
13114          DO NOT scan relocations again, since we've alreadly decided it
13115          and set the flag.  */
13116       const char *syname;
13117       int syndx;
13118       uint32_t insn;
13119
13120       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
13121           && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13122         unused_region = TRUE;
13123       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13124                && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13125         unused_region = FALSE;
13126
13127       /* We're not in the region.  */
13128       if (!unused_region)
13129         continue;
13130
13131       /* _FP_BASE_ must be a GLOBAL symbol.  */
13132       syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
13133       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
13134         continue;
13135
13136       /* The symbol name must be _FP_BASE_.  */
13137       syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
13138       if (strcmp (syname, FP_BASE_NAME) != 0)
13139         continue;
13140
13141       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
13142         {
13143           /* addi.gp  $fp, -256  */
13144           insn = bfd_getb32 (contents + irel->r_offset);
13145           if (insn != INSN_ADDIGP_TO_FP)
13146             continue;
13147         }
13148       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
13149         {
13150           /* addi  $fp, $gp, -256  */
13151           insn = bfd_getb32 (contents + irel->r_offset);
13152           if (insn != INSN_ADDI_GP_TO_FP)
13153             continue;
13154         }
13155       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
13156         {
13157           /* movi  $fp, FP_BASE  */
13158           insn = bfd_getb32 (contents + irel->r_offset);
13159           if (insn != INSN_MOVI_TO_FP)
13160             continue;
13161         }
13162       else
13163         continue;
13164
13165       /* We got here because a FP_BASE instruction is found.  */
13166       if (!insert_nds32_elf_blank_recalc_total
13167           (&relax_blank_list, irel->r_offset, 4))
13168         goto error_return;
13169     }
13170
13171  finish:
13172   if (relax_blank_list)
13173     {
13174       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
13175       relax_blank_list = NULL;
13176     }
13177   return result;
13178
13179  error_return:
13180   result = FALSE;
13181   goto finish;
13182 }
13183
13184 /* This is a version of bfd_generic_get_relocated_section_contents.
13185    We need this variety because relaxation will modify the dwarf
13186    infomation.  When there is undefined symbol reference error mesage,
13187    linker need to dump line number where the symbol be used.  However
13188    the address is be relaxed, it can not get the original dwarf contents.
13189    The variety only modify function call for reading in the section.  */
13190
13191 static bfd_byte *
13192 nds32_elf_get_relocated_section_contents (bfd *abfd,
13193                                           struct bfd_link_info *link_info,
13194                                           struct bfd_link_order *link_order,
13195                                           bfd_byte *data,
13196                                           bfd_boolean relocatable,
13197                                           asymbol **symbols)
13198 {
13199   bfd *input_bfd = link_order->u.indirect.section->owner;
13200   asection *input_section = link_order->u.indirect.section;
13201   long reloc_size;
13202   arelent **reloc_vector;
13203   long reloc_count;
13204
13205   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13206   if (reloc_size < 0)
13207     return NULL;
13208
13209   /* Read in the section.  */
13210   if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13211     return NULL;
13212
13213   if (reloc_size == 0)
13214     return data;
13215
13216   reloc_vector = (arelent **) bfd_malloc (reloc_size);
13217   if (reloc_vector == NULL)
13218     return NULL;
13219
13220   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13221                                         reloc_vector, symbols);
13222   if (reloc_count < 0)
13223     goto error_return;
13224
13225   if (reloc_count > 0)
13226     {
13227       arelent **parent;
13228       for (parent = reloc_vector; *parent != NULL; parent++)
13229         {
13230           char *error_message = NULL;
13231           asymbol *symbol;
13232           bfd_reloc_status_type r;
13233
13234           symbol = *(*parent)->sym_ptr_ptr;
13235           if (symbol->section && discarded_section (symbol->section))
13236             {
13237               bfd_vma off;
13238               static reloc_howto_type none_howto
13239                 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13240                          "unused", FALSE, 0, 0, FALSE);
13241
13242               off = (*parent)->address * OCTETS_PER_BYTE (input_bfd,
13243                                                           input_section);
13244               _bfd_clear_contents ((*parent)->howto, input_bfd,
13245                                    input_section, data, off);
13246               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13247               (*parent)->addend = 0;
13248               (*parent)->howto = &none_howto;
13249               r = bfd_reloc_ok;
13250             }
13251           else
13252             r = bfd_perform_relocation (input_bfd, *parent, data,
13253                                         input_section,
13254                                         relocatable ? abfd : NULL,
13255                                         &error_message);
13256
13257           if (relocatable)
13258             {
13259               asection *os = input_section->output_section;
13260
13261               /* A partial link, so keep the relocs.  */
13262               os->orelocation[os->reloc_count] = *parent;
13263               os->reloc_count++;
13264             }
13265
13266           if (r != bfd_reloc_ok)
13267             {
13268               switch (r)
13269                 {
13270                 case bfd_reloc_undefined:
13271                   (*link_info->callbacks->undefined_symbol)
13272                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13273                      input_bfd, input_section, (*parent)->address, TRUE);
13274                   break;
13275                 case bfd_reloc_dangerous:
13276                   BFD_ASSERT (error_message != NULL);
13277                   (*link_info->callbacks->reloc_dangerous)
13278                     (link_info, error_message,
13279                      input_bfd, input_section, (*parent)->address);
13280                   break;
13281                 case bfd_reloc_overflow:
13282                   (*link_info->callbacks->reloc_overflow)
13283                     (link_info, NULL,
13284                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13285                      (*parent)->howto->name, (*parent)->addend,
13286                      input_bfd, input_section, (*parent)->address);
13287                   break;
13288                 case bfd_reloc_outofrange:
13289                   /* PR ld/13730:
13290                      This error can result when processing some partially
13291                      complete binaries.  Do not abort, but issue an error
13292                      message instead.  */
13293                   link_info->callbacks->einfo
13294                     /* xgettext:c-format */
13295                     (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
13296                      abfd, input_section, * parent);
13297                   goto error_return;
13298
13299                 default:
13300                   abort ();
13301                   break;
13302                 }
13303             }
13304         }
13305     }
13306
13307   free (reloc_vector);
13308   return data;
13309
13310  error_return:
13311   free (reloc_vector);
13312   return NULL;
13313 }
13314
13315 /* Check target symbol.  */
13316
13317 static bfd_boolean
13318 nds32_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
13319 {
13320   if (!sym || !sym->name || sym->name[0] != '$')
13321     return FALSE;
13322   return TRUE;
13323 }
13324
13325 /* nds32 find maybe function sym.  Ignore target special symbol
13326    first, and then go the general function.  */
13327
13328 static bfd_size_type
13329 nds32_elf_maybe_function_sym (const asymbol *sym, asection *sec,
13330                               bfd_vma *code_off)
13331 {
13332   if (nds32_elf_is_target_special_symbol (NULL, (asymbol *) sym))
13333     return 0;
13334
13335   return _bfd_elf_maybe_function_sym (sym, sec, code_off);
13336 }
13337 \f
13338
13339 /* Do TLS model conversion.  */
13340
13341 typedef struct relax_group_list_t
13342 {
13343   Elf_Internal_Rela *relo;
13344   struct relax_group_list_t *next;
13345   struct relax_group_list_t *next_sibling;
13346   int id;
13347 } relax_group_list_t;
13348
13349 int
13350 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem);
13351
13352 int
13353 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem);
13354
13355 void
13356 dump_chain (relax_group_list_t *pHead);
13357
13358 int
13359 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem)
13360 {
13361   relax_group_list_t *pNext = pHead;
13362
13363   /* Find place.  */
13364   while (pNext->next)
13365     {
13366       if (pNext->next->id > (int) pElem->r_addend)
13367         break;
13368
13369       pNext = pNext->next;
13370     }
13371
13372   /* Insert node.  */
13373   relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13374   if (!pNew)
13375     return FALSE;
13376
13377   relax_group_list_t *tmp = pNext->next;
13378   pNext->next = pNew;
13379
13380   pNew->id = pElem->r_addend;
13381   pNew->relo = pElem;
13382   pNew->next = tmp;
13383   pNew->next_sibling = NULL;
13384
13385   return TRUE;
13386 }
13387
13388 int
13389 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem)
13390 {
13391   relax_group_list_t *pNext = pNode;
13392
13393   /* Find place.  */
13394   while (pNext->next_sibling)
13395     {
13396       pNext = pNext->next_sibling;
13397     }
13398
13399   /* Insert node.  */
13400   relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13401   if (!pNew)
13402     return FALSE;
13403
13404   relax_group_list_t *tmp = pNext->next_sibling;
13405   pNext->next_sibling = pNew;
13406
13407   pNew->id = -1;
13408   pNew->relo = pElem;
13409   pNew->next = NULL;
13410   pNew->next_sibling = tmp;
13411
13412   return TRUE;
13413 }
13414
13415 void
13416 dump_chain (relax_group_list_t *pHead)
13417 {
13418   relax_group_list_t *pNext = pHead->next;
13419   while (pNext)
13420     {
13421       printf("group %d @ 0x%08x", pNext->id, (unsigned)pNext->relo->r_offset);
13422       relax_group_list_t *pNextSib = pNext->next_sibling;
13423       while (pNextSib)
13424         {
13425           printf(", %d", (unsigned) ELF32_R_TYPE (pNextSib->relo->r_info));
13426           pNextSib = pNextSib->next_sibling;
13427         }
13428       pNext = pNext->next;
13429       printf("\n");
13430     }
13431 }
13432
13433 /* Check R_NDS32_RELAX_GROUP of each section.
13434    There might be multiple sections in one object file.  */
13435
13436 int
13437 elf32_nds32_check_relax_group (bfd *abfd, asection *asec)
13438 {
13439   elf32_nds32_relax_group_t *relax_group_ptr =
13440     elf32_nds32_relax_group_ptr (abfd);
13441
13442   int min_id = relax_group_ptr->min_id;
13443   int max_id = relax_group_ptr->max_id;
13444
13445   Elf_Internal_Rela *rel;
13446   Elf_Internal_Rela *relend;
13447   Elf_Internal_Rela *relocs;
13448   enum elf_nds32_reloc_type rtype;
13449
13450   do
13451     {
13452       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13453       relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13454                                           TRUE /* keep_memory  */);
13455       if (relocs == NULL)
13456         break;
13457
13458       /* Check R_NDS32_RELAX_GROUP.  */
13459       relend = relocs + asec->reloc_count;
13460       for (rel = relocs; rel < relend; rel++)
13461         {
13462           int id;
13463           rtype = ELF32_R_TYPE (rel->r_info);
13464           if (rtype != R_NDS32_RELAX_GROUP)
13465             continue;
13466
13467           id = rel->r_addend;
13468           if (id < min_id)
13469             min_id = id;
13470           else if (id > max_id)
13471             max_id = id;
13472         }
13473     }
13474   while (FALSE);
13475
13476   if ((relocs != NULL) && (elf_section_data (asec)->relocs != relocs))
13477     free (relocs);
13478
13479   if ((min_id != relax_group_ptr->min_id)
13480       || (max_id != relax_group_ptr->max_id))
13481     {
13482       relax_group_ptr->count = max_id - min_id + 1;
13483       BFD_ASSERT(min_id <= relax_group_ptr->min_id);
13484       relax_group_ptr->min_id = min_id;
13485       BFD_ASSERT(max_id >= relax_group_ptr->max_id);
13486       relax_group_ptr->max_id = max_id;
13487     }
13488
13489   return relax_group_ptr->count;
13490 }
13491
13492 /* Reorder RELAX_GROUP ID when command line option '-r' is applied.  */
13493 struct section_id_list_t *relax_group_section_id_list = NULL;
13494
13495 struct section_id_list_t *
13496 elf32_nds32_lookup_section_id (int id, struct section_id_list_t **lst_ptr)
13497 {
13498   struct section_id_list_t *result = NULL;
13499   struct section_id_list_t *lst = *lst_ptr;
13500
13501   if (NULL == lst)
13502     {
13503       result = (struct section_id_list_t *) calloc
13504         (1, sizeof (struct section_id_list_t));
13505       BFD_ASSERT (result); /* Feed me.  */
13506       result->id = id;
13507       *lst_ptr = result;
13508     }
13509   else
13510     {
13511       struct section_id_list_t *cur = lst;
13512       struct section_id_list_t *prv = NULL;
13513       struct section_id_list_t *sec = NULL;
13514
13515       while (cur)
13516         {
13517           if (cur->id < id)
13518             {
13519               prv = cur;
13520               cur = cur->next;
13521               continue;
13522             }
13523
13524           if (cur->id > id)
13525             {
13526               cur = NULL; /* To insert after prv.  */
13527               sec = cur;  /* In case prv == NULL.  */
13528             }
13529
13530           break;
13531         }
13532
13533       if (NULL == cur)
13534         {
13535           /* Insert after prv.  */
13536           result = (struct section_id_list_t *) calloc
13537             (1, sizeof (struct section_id_list_t));
13538           BFD_ASSERT (result); /* Feed me.  */
13539           result->id = id;
13540           if (NULL != prv)
13541             {
13542               result->next = prv->next;
13543               prv->next = result;
13544             }
13545           else
13546             {
13547               *lst_ptr = result;
13548               result->next = sec;
13549             }
13550         }
13551     }
13552
13553   return result;
13554 }
13555
13556 int
13557 elf32_nds32_unify_relax_group (bfd *abfd, asection *asec)
13558 {
13559   static int next_relax_group_bias = 0;
13560
13561   elf32_nds32_relax_group_t *relax_group_ptr =
13562     elf32_nds32_relax_group_ptr (abfd);
13563
13564   bfd_boolean result = TRUE;
13565   Elf_Internal_Rela *rel;
13566   Elf_Internal_Rela *relend;
13567   Elf_Internal_Rela *relocs = NULL;
13568   enum elf_nds32_reloc_type rtype;
13569   struct section_id_list_t *node = NULL;
13570   int count = 0;
13571
13572   do
13573     {
13574       if (0 == relax_group_ptr->count)
13575         break;
13576
13577       /* Check if this section has been handled.  */
13578       node = elf32_nds32_lookup_section_id (asec->id, &relax_group_section_id_list);
13579       if (NULL == node)
13580         break; /* Hit, the section id has handled.  */
13581
13582       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13583       relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13584                                           TRUE /* keep_memory  */);
13585       if (relocs == NULL)
13586         {
13587           BFD_ASSERT (0); /* feed me */
13588           break;
13589         }
13590
13591       /* Allocate group id bias for this bfd!  */
13592       if (0 == relax_group_ptr->init)
13593         {
13594           relax_group_ptr->bias = next_relax_group_bias;
13595           next_relax_group_bias += relax_group_ptr->count;
13596           relax_group_ptr->init = 1;
13597         }
13598
13599       /* Reorder relax group groups.  */
13600       relend = relocs + asec->reloc_count;
13601       for (rel = relocs; rel < relend; rel++)
13602         {
13603           rtype = ELF32_R_TYPE(rel->r_info);
13604           if (rtype != R_NDS32_RELAX_GROUP)
13605             continue;
13606
13607           /* Change it.  */
13608           rel->r_addend += relax_group_ptr->bias;
13609           /* Debugging count.  */
13610           count++;
13611         }
13612     }
13613   while (FALSE);
13614
13615   if (relocs != NULL && elf_section_data (asec)->relocs != relocs)
13616     free (relocs);
13617
13618   return result;
13619 }
13620
13621 int
13622 nds32_elf_unify_tls_model (bfd *inbfd, asection *insec, bfd_byte *incontents,
13623                            struct bfd_link_info *lnkinfo)
13624 {
13625   bfd_boolean result = TRUE;
13626   Elf_Internal_Rela *irel;
13627   Elf_Internal_Rela *irelend;
13628   Elf_Internal_Rela *internal_relocs;
13629   unsigned long r_symndx;
13630   enum elf_nds32_reloc_type r_type;
13631
13632   Elf_Internal_Sym *local_syms = NULL;
13633   bfd_byte *contents = NULL;
13634
13635   relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
13636
13637   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
13638   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13639   sym_hashes = elf_sym_hashes (inbfd);
13640   sym_hashes_end =
13641     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
13642   if (!elf_bad_symtab (inbfd))
13643     sym_hashes_end -= symtab_hdr->sh_info;
13644
13645   /* Reorder RELAX_GROUP when command line option '-r' is applied.  */
13646   if (bfd_link_relocatable (lnkinfo))
13647     {
13648       elf32_nds32_unify_relax_group (inbfd, insec);
13649       return result;
13650     }
13651
13652   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13653   internal_relocs = _bfd_elf_link_read_relocs (inbfd, insec, NULL, NULL,
13654                                                TRUE /* keep_memory  */);
13655   if (internal_relocs == NULL)
13656     goto error_return;
13657
13658   irelend = internal_relocs + insec->reloc_count;
13659   irel = find_relocs_at_address (internal_relocs, internal_relocs,
13660                                  irelend, R_NDS32_RELAX_ENTRY);
13661   if (irel == irelend)
13662     goto finish;
13663
13664   /* Chain/remove groups.  */
13665   for (irel = internal_relocs; irel < irelend; irel++)
13666     {
13667       r_symndx = ELF32_R_SYM (irel->r_info);
13668       r_type = ELF32_R_TYPE (irel->r_info);
13669       if (r_type != R_NDS32_RELAX_GROUP)
13670         continue;
13671
13672       /* Remove it.  */
13673       irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_NONE);
13674       /* Chain it now.  */
13675       if (!list_insert (&chain, irel))
13676         goto error_return;
13677     }
13678
13679   /* Collect group relocations.  */
13680   /* Presume relocations are sorted.  */
13681   relax_group_list_t *pNext = chain.next;
13682   while (pNext)
13683     {
13684       for (irel = internal_relocs; irel < irelend; irel++)
13685         {
13686           if (irel->r_offset == pNext->relo->r_offset)
13687             {
13688               /* Ignore Non-TLS relocation types.  */
13689               r_type = ELF32_R_TYPE (irel->r_info);
13690               if ((R_NDS32_TLS_LE_HI20 > r_type)
13691                   || (R_NDS32_RELAX_ENTRY == r_type))
13692                 continue;
13693
13694               if (!list_insert_sibling (pNext, irel))
13695                 goto error_return;
13696             }
13697           else if (irel->r_offset > pNext->relo->r_offset)
13698             {
13699               pNext = pNext->next;
13700               if (!pNext)
13701                 break;
13702
13703               bfd_vma current_offset = pNext->relo->r_offset;
13704               if (irel->r_offset > current_offset)
13705                 irel = internal_relocs; /* restart from head */
13706               else
13707                 --irel; /* Check current irel again.  */
13708               continue;
13709             }
13710           else
13711             {
13712               /* This shouldn't be reached.  */
13713             }
13714         }
13715       if (pNext)
13716         pNext = pNext->next;
13717     }
13718
13719 #ifdef DUBUG_VERBOSE
13720   dump_chain(&chain);
13721 #endif
13722
13723   /* Get symbol table and section content.  */
13724   if (incontents)
13725     contents = incontents;
13726   else if (!nds32_get_section_contents (inbfd, insec, &contents, TRUE)
13727            || !nds32_get_local_syms (inbfd, insec, &local_syms))
13728     goto error_return;
13729
13730   char *local_got_tls_type = elf32_nds32_local_got_tls_type (inbfd);
13731
13732   /* Convert TLS model each group if necessary.  */
13733   pNext = chain.next;
13734
13735   int cur_grp_id = -1;
13736   int sethi_rt = -1;
13737   int add_rt = -1;
13738   enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
13739
13740   tls_type = org_tls_type = eff_tls_type = 0;
13741
13742   while (pNext)
13743     {
13744       relax_group_list_t *pNextSig = pNext->next_sibling;
13745       while (pNextSig)
13746         {
13747           struct elf_link_hash_entry *h = NULL;
13748
13749           irel = pNextSig->relo;
13750           r_symndx = ELF32_R_SYM(irel->r_info);
13751           r_type = ELF32_R_TYPE(irel->r_info);
13752
13753           if (pNext->id != cur_grp_id)
13754             {
13755               cur_grp_id = pNext->id;
13756               org_tls_type = get_tls_type (r_type, NULL);
13757               if (r_symndx >= symtab_hdr->sh_info)
13758                 {
13759                   h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13760                   while (h->root.type == bfd_link_hash_indirect
13761                          || h->root.type == bfd_link_hash_warning)
13762                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
13763                   tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
13764                 }
13765               else
13766                 {
13767                   tls_type = local_got_tls_type
13768                     ? local_got_tls_type[r_symndx]
13769                     : GOT_NORMAL;
13770                 }
13771
13772               eff_tls_type = 1 << (fls (tls_type) - 1);
13773               sethi_rt = N32_RT5(bfd_getb32 (contents + irel->r_offset));
13774             }
13775
13776           if (eff_tls_type != org_tls_type)
13777             {
13778               switch (org_tls_type)
13779                 {
13780                   /* DESC to IEGP/IE/LE.  */
13781                 case GOT_TLS_DESC:
13782                   switch (eff_tls_type)
13783                     {
13784                     case GOT_TLS_IE:
13785                       switch (r_type)
13786                         {
13787                         case R_NDS32_TLS_DESC_HI20:
13788                           irel->r_info = ELF32_R_INFO(r_symndx,
13789                                                       R_NDS32_TLS_IE_HI20);
13790                           break;
13791                         case R_NDS32_TLS_DESC_LO12:
13792                           irel->r_info = ELF32_R_INFO(r_symndx,
13793                                                       R_NDS32_TLS_IE_LO12);
13794                           break;
13795                         case R_NDS32_TLS_DESC_ADD:
13796                           {
13797                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13798                             add_rt = N32_RT5 (insn);
13799                             insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13800                             bfd_putb32 (insn, contents + irel->r_offset);
13801
13802                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13803                           }
13804                           break;
13805                         case R_NDS32_TLS_DESC_FUNC:
13806                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13807                           irel->r_info = ELF32_R_INFO(r_symndx,
13808                                                       R_NDS32_RELAX_REMOVE);
13809                           break;
13810                         case R_NDS32_TLS_DESC_CALL:
13811                           {
13812                             uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13813                                                      REG_TP);
13814                             bfd_putb32 (insn, contents + irel->r_offset);
13815
13816                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13817                           }
13818                           break;
13819                         case R_NDS32_LOADSTORE:
13820                         case R_NDS32_PTR:
13821                         case R_NDS32_PTR_RESOLVED:
13822                         case R_NDS32_NONE:
13823                         case R_NDS32_LABEL:
13824                           break;
13825                         default:
13826                           BFD_ASSERT(0);
13827                           break;
13828                         }
13829                       break;
13830                     case GOT_TLS_IEGP:
13831                       switch (r_type)
13832                         {
13833                         case R_NDS32_TLS_DESC_HI20:
13834                           irel->r_info = ELF32_R_INFO(r_symndx,
13835                                                       R_NDS32_TLS_IEGP_HI20);
13836                           break;
13837                         case R_NDS32_TLS_DESC_LO12:
13838                           irel->r_info = ELF32_R_INFO(r_symndx,
13839                                                       R_NDS32_TLS_IEGP_LO12);
13840                           break;
13841                         case R_NDS32_TLS_DESC_ADD:
13842                           {
13843                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13844                             add_rt = N32_RT5 (insn);
13845                             insn = N32_MEM(LW, add_rt, sethi_rt, REG_GP, 0);
13846                             bfd_putb32 (insn, contents + irel->r_offset);
13847
13848                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13849                           }
13850                           break;
13851                         case R_NDS32_TLS_DESC_FUNC:
13852                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13853                           irel->r_info = ELF32_R_INFO(r_symndx,
13854                                                       R_NDS32_RELAX_REMOVE);
13855                           break;
13856                         case R_NDS32_TLS_DESC_CALL:
13857                           {
13858                             uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13859                                                      REG_TP);
13860                             bfd_putb32 (insn, contents + irel->r_offset);
13861
13862                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13863                           }
13864                           break;
13865                         case R_NDS32_LOADSTORE:
13866                         case R_NDS32_PTR:
13867                         case R_NDS32_PTR_RESOLVED:
13868                         case R_NDS32_NONE:
13869                         case R_NDS32_LABEL:
13870                           break;
13871                         default:
13872                           BFD_ASSERT(0);
13873                           break;
13874                         }
13875                       break;
13876                     case GOT_TLS_LE:
13877                       switch (r_type)
13878                         {
13879                         case R_NDS32_TLS_DESC_HI20:
13880                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13881                           break;
13882                         case R_NDS32_TLS_DESC_LO12:
13883                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13884                           break;
13885                         case R_NDS32_TLS_DESC_ADD:
13886                           {
13887                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13888
13889                             add_rt = N32_RT5 (insn);
13890                             insn = N32_ALU1 (ADD, REG_R0, sethi_rt, REG_TP);
13891                             bfd_putb32 (insn, contents + irel->r_offset);
13892
13893                             irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_ADD);
13894                           }
13895                           break;
13896                         case R_NDS32_TLS_DESC_FUNC:
13897                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13898                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13899                           break;
13900                         case R_NDS32_TLS_DESC_CALL:
13901                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13902                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13903                           break;
13904                         case R_NDS32_LOADSTORE:
13905                         case R_NDS32_PTR:
13906                         case R_NDS32_PTR_RESOLVED:
13907                         case R_NDS32_NONE:
13908                         case R_NDS32_LABEL:
13909                           break;
13910                         default:
13911                           BFD_ASSERT(0);
13912                           break;
13913                         }
13914                       break;
13915                     default:
13916                       break;
13917                     }
13918                   break;
13919                   /* IEGP to IE/LE.  */
13920                 case GOT_TLS_IEGP:
13921                   switch (eff_tls_type)
13922                     {
13923                     case GOT_TLS_IE:
13924                       switch (r_type)
13925                         {
13926                         case R_NDS32_TLS_IEGP_HI20:
13927                           irel->r_info = ELF32_R_INFO(r_symndx,
13928                                                       R_NDS32_TLS_IE_HI20);
13929                           break;
13930                         case R_NDS32_TLS_IEGP_LO12:
13931                           irel->r_info = ELF32_R_INFO(r_symndx,
13932                                                       R_NDS32_TLS_IE_LO12);
13933                           break;
13934                         case R_NDS32_PTR_RESOLVED:
13935                           {
13936                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13937
13938                             add_rt = N32_RT5 (insn);
13939                             insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13940                             bfd_putb32 (insn, contents + irel->r_offset);
13941                           }
13942                           break;
13943                         case R_NDS32_TLS_IEGP_LW:
13944                           break;
13945                         case R_NDS32_LOADSTORE:
13946                         case R_NDS32_PTR:
13947                         case R_NDS32_NONE:
13948                         case R_NDS32_LABEL:
13949                           break;
13950                         default:
13951                           BFD_ASSERT(0);
13952                           break;
13953                         }
13954                       break;
13955                     case GOT_TLS_LE:
13956                       switch (r_type)
13957                         {
13958                         case R_NDS32_TLS_IEGP_HI20:
13959                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13960                           break;
13961                         case R_NDS32_TLS_IEGP_LO12:
13962                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13963                           break;
13964                         case R_NDS32_TLS_IEGP_LW:
13965                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13966                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13967                           break;
13968                         case R_NDS32_LOADSTORE:
13969                         case R_NDS32_PTR:
13970                         case R_NDS32_NONE:
13971                         case R_NDS32_LABEL:
13972                         case R_NDS32_PTR_RESOLVED:
13973                           break;
13974                         default:
13975                           BFD_ASSERT(0);
13976                           break;
13977                         }
13978                       break;
13979                     default:
13980                       break;
13981                     }
13982                   break;
13983                   /* IE to LE. */
13984                 case GOT_TLS_IE:
13985                   switch (eff_tls_type)
13986                     {
13987                     case GOT_TLS_LE:
13988                       switch (r_type)
13989                         {
13990                         case R_NDS32_TLS_IE_HI20:
13991                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13992                           break;
13993                         case R_NDS32_TLS_IE_LO12S2:
13994                           {
13995                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13996
13997                             add_rt = N32_RT5 (insn);
13998                             insn = N32_TYPE2 (ORI, add_rt, sethi_rt, 0);
13999                             bfd_putb32 (insn, contents + irel->r_offset);
14000
14001                             irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
14002                           }
14003                           break;
14004                         case R_NDS32_LOADSTORE:
14005                         case R_NDS32_PTR:
14006                         case R_NDS32_NONE:
14007                         case R_NDS32_LABEL:
14008                           break;
14009                         default:
14010                           BFD_ASSERT(0);
14011                           break;
14012                         }
14013                       break;
14014                     default:
14015                       break;
14016                     }
14017                   break;
14018                 default:
14019                   break;
14020                 }
14021             }
14022           pNextSig = pNextSig->next_sibling;
14023         }
14024
14025 #if 1
14026       pNext = pNext->next;
14027 #else
14028       while (pNext)
14029         {
14030           if (pNext->id != cur_grp_id)
14031             break;
14032           pNext = pNext->next;
14033         }
14034 #endif
14035     }
14036
14037  finish:
14038   if (incontents)
14039     contents = NULL;
14040
14041   if (internal_relocs != NULL
14042       && elf_section_data (insec)->relocs != internal_relocs)
14043     free (internal_relocs);
14044
14045   if (contents != NULL
14046       && elf_section_data (insec)->this_hdr.contents != contents)
14047     free (contents);
14048
14049   if (local_syms != NULL && symtab_hdr->contents != (bfd_byte *) local_syms)
14050     free (local_syms);
14051
14052   if (chain.next)
14053     {
14054       pNext = chain.next;
14055       relax_group_list_t *pDel;
14056       while (pNext)
14057         {
14058           pDel = pNext;
14059           pNext = pNext->next;
14060           free (pDel);
14061         }
14062     }
14063
14064   return result;
14065
14066  error_return:
14067   result = FALSE;
14068   goto finish;
14069 }
14070
14071 /* End TLS model conversion.  */
14072
14073 #define ELF_ARCH                                bfd_arch_nds32
14074 #define ELF_MACHINE_CODE                        EM_NDS32
14075 #define ELF_MAXPAGESIZE                         0x1000
14076 #define ELF_TARGET_ID                           NDS32_ELF_DATA
14077
14078 #define TARGET_BIG_SYM                          nds32_elf32_be_vec
14079 #define TARGET_BIG_NAME                         "elf32-nds32be"
14080 #define TARGET_LITTLE_SYM                       nds32_elf32_le_vec
14081 #define TARGET_LITTLE_NAME                      "elf32-nds32le"
14082
14083 #define elf_info_to_howto                       nds32_info_to_howto
14084 #define elf_info_to_howto_rel                   nds32_info_to_howto_rel
14085
14086 #define bfd_elf32_bfd_link_hash_table_create    nds32_elf_link_hash_table_create
14087 #define bfd_elf32_bfd_merge_private_bfd_data    nds32_elf_merge_private_bfd_data
14088 #define bfd_elf32_bfd_print_private_bfd_data    nds32_elf_print_private_bfd_data
14089 #define bfd_elf32_bfd_relax_section             nds32_elf_relax_section
14090 #define bfd_elf32_bfd_set_private_flags         nds32_elf_set_private_flags
14091
14092 #define bfd_elf32_mkobject                      nds32_elf_mkobject
14093 #define elf_backend_action_discarded            nds32_elf_action_discarded
14094 #define elf_backend_add_symbol_hook             nds32_elf_add_symbol_hook
14095 #define elf_backend_check_relocs                nds32_elf_check_relocs
14096 #define elf_backend_adjust_dynamic_symbol       nds32_elf_adjust_dynamic_symbol
14097 #define elf_backend_create_dynamic_sections     nds32_elf_create_dynamic_sections
14098 #define elf_backend_finish_dynamic_sections     nds32_elf_finish_dynamic_sections
14099 #define elf_backend_finish_dynamic_symbol       nds32_elf_finish_dynamic_symbol
14100 #define elf_backend_size_dynamic_sections       nds32_elf_size_dynamic_sections
14101 #define elf_backend_relocate_section            nds32_elf_relocate_section
14102 #define elf_backend_gc_mark_hook                nds32_elf_gc_mark_hook
14103 #define elf_backend_grok_prstatus               nds32_elf_grok_prstatus
14104 #define elf_backend_grok_psinfo                 nds32_elf_grok_psinfo
14105 #define elf_backend_reloc_type_class            nds32_elf_reloc_type_class
14106 #define elf_backend_copy_indirect_symbol        nds32_elf_copy_indirect_symbol
14107 #define elf_backend_link_output_symbol_hook     nds32_elf_output_symbol_hook
14108 #define elf_backend_output_arch_syms            nds32_elf_output_arch_syms
14109 #define elf_backend_object_p                    nds32_elf_object_p
14110 #define elf_backend_final_write_processing      nds32_elf_final_write_processing
14111 #define elf_backend_special_sections            nds32_elf_special_sections
14112 #define elf_backend_section_flags               nds32_elf_section_flags
14113 #define bfd_elf32_bfd_get_relocated_section_contents \
14114                                 nds32_elf_get_relocated_section_contents
14115 #define bfd_elf32_bfd_is_target_special_symbol  nds32_elf_is_target_special_symbol
14116 #define elf_backend_maybe_function_sym          nds32_elf_maybe_function_sym
14117
14118 #define elf_backend_can_gc_sections             1
14119 #define elf_backend_can_refcount                1
14120 #define elf_backend_want_got_plt                1
14121 #define elf_backend_plt_readonly                1
14122 #define elf_backend_want_plt_sym                0
14123 #define elf_backend_got_header_size             12
14124 #define elf_backend_may_use_rel_p               1
14125 #define elf_backend_default_use_rela_p          1
14126 #define elf_backend_may_use_rela_p              1
14127 #define elf_backend_dtrel_excludes_plt          0
14128
14129 #include "elf32-target.h"
14130
14131 #undef ELF_MAXPAGESIZE
14132 #define ELF_MAXPAGESIZE                         0x2000
14133
14134 #undef  TARGET_BIG_SYM
14135 #define TARGET_BIG_SYM                          nds32_elf32_linux_be_vec
14136 #undef  TARGET_BIG_NAME
14137 #define TARGET_BIG_NAME                         "elf32-nds32be-linux"
14138 #undef  TARGET_LITTLE_SYM
14139 #define TARGET_LITTLE_SYM                       nds32_elf32_linux_le_vec
14140 #undef  TARGET_LITTLE_NAME
14141 #define TARGET_LITTLE_NAME                      "elf32-nds32le-linux"
14142 #undef  elf32_bed
14143 #define elf32_bed                               elf32_nds32_lin_bed
14144
14145 #include "elf32-target.h"