bfd/elf32-nds32.c

   1 /* NDS32-specific support for 32-bit ELF.
   2    Copyright (C) 2012-2018 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 "bfd_stdint.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "libiberty.h"
  30 #include "bfd_stdint.h"
  31 #include "elf/nds32.h"
  32 #include "opcode/nds32.h"
  33 #include "elf32-nds32.h"
  34 #include "opcode/cgen.h"
  35 #include "../opcodes/nds32-opc.h"
  36
  37 /* Relocation HOWTO functions.  */
  38 static bfd_reloc_status_type nds32_elf_ignore_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type nds32_elf_hi20_reloc
  43   (bfd *, arelent *, asymbol *, void *,
  44    asection *, bfd *, char **);
  45 static bfd_reloc_status_type nds32_elf_lo12_reloc
  46   (bfd *, arelent *, asymbol *, void *,
  47    asection *, bfd *, char **);
  48 static bfd_reloc_status_type nds32_elf_generic_reloc
  49   (bfd *, arelent *, asymbol *, void *,
  50    asection *, bfd *, char **);
  51 static bfd_reloc_status_type nds32_elf_sda15_reloc
  52   (bfd *, arelent *, asymbol *, void *,
  53    asection *, bfd *, char **);
  54
  55 /* Helper functions for HOWTO.  */
  56 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
  57   (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
  58    asection *, bfd_vma, bfd_vma);
  59
  60 /* Nds32 helper functions.  */
  61 static bfd_vma calculate_memory_address
  62 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
  63 static int nds32_get_section_contents (bfd *, asection *,
  64                                        bfd_byte **, bfd_boolean);
  65 static bfd_boolean nds32_elf_ex9_build_hash_table
  66 (bfd *, asection *, struct bfd_link_info *);
  67 static bfd_boolean nds32_elf_ex9_itb_base (struct bfd_link_info *);
  68 static void nds32_elf_ex9_import_table (struct bfd_link_info *);
  69 static void nds32_elf_ex9_finish (struct bfd_link_info *);
  70 static void nds32_elf_ex9_reloc_jmp (struct bfd_link_info *);
  71 static void nds32_elf_get_insn_with_reg
  72   (Elf_Internal_Rela *, uint32_t, uint32_t *);
  73 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
  74                                  Elf_Internal_Sym **);
  75 static bfd_boolean nds32_elf_ex9_replace_instruction
  76   (struct bfd_link_info *, bfd *, asection *);
  77 static bfd_boolean nds32_elf_ifc_calc (struct bfd_link_info *, bfd *,
  78                                        asection *);
  79 static bfd_boolean nds32_elf_ifc_finish (struct bfd_link_info *);
  80 static bfd_boolean nds32_elf_ifc_replace (struct bfd_link_info *);
  81 static bfd_boolean nds32_elf_ifc_reloc (void);
  82 static bfd_boolean  nds32_relax_fp_as_gp
  83   (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
  84    Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
  85    Elf_Internal_Sym *isymbuf);
  86 static bfd_boolean nds32_fag_remove_unused_fpbase
  87   (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
  88    Elf_Internal_Rela *irelend);
  89
  90 enum
  91 {
  92   MACH_V1 = bfd_mach_n1h,
  93   MACH_V2 = bfd_mach_n1h_v2,
  94   MACH_V3 = bfd_mach_n1h_v3,
  95   MACH_V3M = bfd_mach_n1h_v3m
  96 };
  97
  98 #define MIN(a, b) ((a) > (b) ? (b) : (a))
  99 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 100
 101 /* The name of the dynamic interpreter.  This is put in the .interp
 102    section.  */
 103 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 104
 105 /* The nop opcode we use.  */
 106 #define NDS32_NOP32 0x40000009
 107 #define NDS32_NOP16 0x9200
 108
 109 /* The size in bytes of an entry in the procedure linkage table.  */
 110 #define PLT_ENTRY_SIZE 24
 111 #define PLT_HEADER_SIZE 24
 112
 113 /* The first entry in a procedure linkage table are reserved,
 114    and the initial contents are unimportant (we zero them out).
 115    Subsequent entries look like this.  */
 116 #define PLT0_ENTRY_WORD0  0x46f00000            /* sethi   r15, HI20(.got+4)      */
 117 #define PLT0_ENTRY_WORD1  0x58f78000            /* ori     r15, r25, LO12(.got+4) */
 118 #define PLT0_ENTRY_WORD2  0x05178000            /* lwi     r17, [r15+0]           */
 119 #define PLT0_ENTRY_WORD3  0x04f78001            /* lwi     r15, [r15+4]           */
 120 #define PLT0_ENTRY_WORD4  0x4a003c00            /* jr      r15                    */
 121
 122 /* $ta is change to $r15 (from $r25).  */
 123 #define PLT0_PIC_ENTRY_WORD0  0x46f00000        /* sethi   r15, HI20(got[1]@GOT)  */
 124 #define PLT0_PIC_ENTRY_WORD1  0x58f78000        /* ori     r15, r15, LO12(got[1]@GOT) */
 125 #define PLT0_PIC_ENTRY_WORD2  0x40f7f400        /* add     r15, gp, r15           */
 126 #define PLT0_PIC_ENTRY_WORD3  0x05178000        /* lwi     r17, [r15+0]           */
 127 #define PLT0_PIC_ENTRY_WORD4  0x04f78001        /* lwi     r15, [r15+4]           */
 128 #define PLT0_PIC_ENTRY_WORD5  0x4a003c00        /* jr      r15                    */
 129
 130 #define PLT_ENTRY_WORD0  0x46f00000             /* sethi   r15, HI20(&got[n+3])      */
 131 #define PLT_ENTRY_WORD1  0x04f78000             /* lwi     r15, r15, LO12(&got[n+3]) */
 132 #define PLT_ENTRY_WORD2  0x4a003c00             /* jr      r15                       */
 133 #define PLT_ENTRY_WORD3  0x45000000             /* movi    r16, sizeof(RELA) * n     */
 134 #define PLT_ENTRY_WORD4  0x48000000             /* j      .plt0.                     */
 135
 136 #define PLT_PIC_ENTRY_WORD0  0x46f00000         /* sethi  r15, HI20(got[n+3]@GOT)    */
 137 #define PLT_PIC_ENTRY_WORD1  0x58f78000         /* ori    r15, r15,    LO12(got[n+3]@GOT) */
 138 #define PLT_PIC_ENTRY_WORD2  0x38febc02         /* lw     r15, [gp+r15]              */
 139 #define PLT_PIC_ENTRY_WORD3  0x4a003c00         /* jr     r15                        */
 140 #define PLT_PIC_ENTRY_WORD4  0x45000000         /* movi   r16, sizeof(RELA) * n      */
 141 #define PLT_PIC_ENTRY_WORD5  0x48000000         /* j      .plt0                      */
 142
 143 /* These are macros used to get the relocation accurate value.  */
 144 #define ACCURATE_8BIT_S1        (0x100)
 145 #define ACCURATE_U9BIT_S1       (0x400)
 146 #define ACCURATE_12BIT_S1       (0x2000)
 147 #define ACCURATE_14BIT_S1       (0x4000)
 148 #define ACCURATE_19BIT          (0x40000)
 149
 150 /* These are macros used to get the relocation conservative value.  */
 151 #define CONSERVATIVE_8BIT_S1    (0x100 - 4)
 152 #define CONSERVATIVE_14BIT_S1   (0x4000 - 4)
 153 #define CONSERVATIVE_16BIT_S1   (0x10000 - 4)
 154 #define CONSERVATIVE_24BIT_S1   (0x1000000 - 4)
 155 /* These must be more conservative because the address may be in
 156    different segment.  */
 157 #define CONSERVATIVE_15BIT      (0x4000 - 0x1000)
 158 #define CONSERVATIVE_15BIT_S1   (0x8000 - 0x1000)
 159 #define CONSERVATIVE_15BIT_S2   (0x10000 - 0x1000)
 160 #define CONSERVATIVE_19BIT      (0x40000 - 0x1000)
 161 #define CONSERVATIVE_20BIT      (0x80000 - 0x1000)
 162
 163 /* Size of small data/bss sections, used to calculate SDA_BASE.  */
 164 static long got_size = 0;
 165 static int is_SDA_BASE_set = 0;
 166 static int is_ITB_BASE_set = 0;
 167
 168 /* Convert ELF-VER in eflags to string for debugging purpose.  */
 169 static const char *const nds32_elfver_strtab[] =
 170 {
 171   "ELF-1.2",
 172   "ELF-1.3",
 173   "ELF-1.4",
 174 };
 175
 176 /* The nds32 linker needs to keep track of the number of relocs that it
 177    decides to copy in check_relocs for each symbol.  This is so that
 178    it can discard PC relative relocs if it doesn't need them when
 179    linking with -Bsymbolic.  We store the information in a field
 180    extending the regular ELF linker hash table.  */
 181
 182 /* This structure keeps track of the number of PC relative relocs we
 183    have copied for a given symbol.  */
 184
 185 struct elf_nds32_pcrel_relocs_copied
 186 {
 187   /* Next section.  */
 188   struct elf_nds32_pcrel_relocs_copied *next;
 189   /* A section in dynobj.  */
 190   asection *section;
 191   /* Number of relocs copied in this section.  */
 192   bfd_size_type count;
 193 };
 194
 195 /* Nds32 ELF linker hash entry.  */
 196
 197 struct elf_nds32_link_hash_entry
 198 {
 199   struct elf_link_hash_entry root;
 200
 201   /* Track dynamic relocs copied for this symbol.  */
 202   struct elf_dyn_relocs *dyn_relocs;
 203
 204   /* For checking relocation type.  */
 205 #define GOT_UNKNOWN     0
 206 #define GOT_NORMAL      1
 207 #define GOT_TLS_IE      2
 208   unsigned int tls_type;
 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 static size_t ex9_relax_size = 0;               /* Save ex9 predicted reducing size.  */
 216
 217 /* The offset for executable tls relaxation.  */
 218 #define TP_OFFSET 0x0
 219
 220 struct elf_nds32_obj_tdata
 221 {
 222   struct elf_obj_tdata root;
 223
 224   /* tls_type for each local got entry.  */
 225   char *local_got_tls_type;
 226 };
 227
 228 #define elf_nds32_tdata(bfd) \
 229   ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
 230
 231 #define elf32_nds32_local_got_tls_type(bfd) \
 232   (elf_nds32_tdata (bfd)->local_got_tls_type)
 233
 234 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
 235
 236 static bfd_boolean
 237 nds32_elf_mkobject (bfd *abfd)
 238 {
 239   return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
 240                                   NDS32_ELF_DATA);
 241 }
 242
 243 /* Relocations used for relocation.  */
 244 static reloc_howto_type nds32_elf_howto_table[] =
 245 {
 246   /* This reloc does nothing.  */
 247   HOWTO (R_NDS32_NONE,          /* type */
 248          0,                     /* rightshift */
 249          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          0,                     /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_dont,        /* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_NDS32_NONE",        /* name */
 256          FALSE,                 /* partial_inplace */
 257          0,                     /* src_mask */
 258          0,                     /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* A 16 bit absolute relocation.  */
 262   HOWTO (R_NDS32_16,            /* type */
 263          0,                     /* rightshift */
 264          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          16,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield,    /* complain_on_overflow */
 269          nds32_elf_generic_reloc,       /* special_function */
 270          "R_NDS32_16",          /* name */
 271          FALSE,                 /* partial_inplace */
 272          0xffff,                /* src_mask */
 273          0xffff,                /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* A 32 bit absolute relocation.  */
 277   HOWTO (R_NDS32_32,            /* 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          nds32_elf_generic_reloc,       /* special_function */
 285          "R_NDS32_32",          /* name */
 286          FALSE,                 /* partial_inplace */
 287          0xffffffff,            /* src_mask */
 288          0xffffffff,            /* dst_mask */
 289          FALSE),                /* pcrel_offset */
 290
 291   /* A 20 bit address.  */
 292   HOWTO (R_NDS32_20,            /* type */
 293          0,                     /* rightshift */
 294          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          20,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_unsigned,    /* complain_on_overflow */
 299          nds32_elf_generic_reloc,       /* special_function */
 300          "R_NDS32_20",          /* name */
 301          FALSE,                 /* partial_inplace */
 302          0xfffff,               /* src_mask */
 303          0xfffff,               /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* An PC Relative 9-bit relocation, shifted by 2.
 307      This reloc is complicated because relocations are relative to pc & -4.
 308      i.e. branches in the right insn slot use the address of the left insn
 309      slot for pc.  */
 310   /* ??? It's not clear whether this should have partial_inplace set or not.
 311      Branch relaxing in the assembler can store the addend in the insn,
 312      and if bfd_install_relocation gets called the addend may get added
 313      again.  */
 314   HOWTO (R_NDS32_9_PCREL,       /* type */
 315          1,                     /* rightshift */
 316          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          8,                     /* bitsize */
 318          TRUE,                  /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_signed,      /* complain_on_overflow */
 321          nds32_elf_9_pcrel_reloc,       /* special_function */
 322          "R_NDS32_9_PCREL",     /* name */
 323          FALSE,                 /* partial_inplace */
 324          0xff,                  /* src_mask */
 325          0xff,                  /* dst_mask */
 326          TRUE),                 /* pcrel_offset */
 327
 328   /* A relative 15 bit relocation, right shifted by 1.  */
 329   HOWTO (R_NDS32_15_PCREL,      /* type */
 330          1,                     /* rightshift */
 331          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 332          14,                    /* bitsize */
 333          TRUE,                  /* pc_relative */
 334          0,                     /* bitpos */
 335          complain_overflow_signed,      /* complain_on_overflow */
 336          bfd_elf_generic_reloc, /* special_function */
 337          "R_NDS32_15_PCREL",    /* name */
 338          FALSE,                 /* partial_inplace */
 339          0x3fff,                /* src_mask */
 340          0x3fff,                /* dst_mask */
 341          TRUE),                 /* pcrel_offset */
 342
 343   /* A relative 17 bit relocation, right shifted by 1.  */
 344   HOWTO (R_NDS32_17_PCREL,      /* type */
 345          1,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          16,                    /* bitsize */
 348          TRUE,                  /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_signed,      /* complain_on_overflow */
 351          bfd_elf_generic_reloc, /* special_function */
 352          "R_NDS32_17_PCREL",    /* name */
 353          FALSE,                 /* partial_inplace */
 354          0xffff,                /* src_mask */
 355          0xffff,                /* dst_mask */
 356          TRUE),                 /* pcrel_offset */
 357
 358   /* A relative 25 bit relocation, right shifted by 1.  */
 359   /* ??? It's not clear whether this should have partial_inplace set or not.
 360      Branch relaxing in the assembler can store the addend in the insn,
 361      and if bfd_install_relocation gets called the addend may get added
 362      again.  */
 363   HOWTO (R_NDS32_25_PCREL,      /* type */
 364          1,                     /* rightshift */
 365          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 366          24,                    /* bitsize */
 367          TRUE,                  /* pc_relative */
 368          0,                     /* bitpos */
 369          complain_overflow_signed,      /* complain_on_overflow */
 370          bfd_elf_generic_reloc, /* special_function */
 371          "R_NDS32_25_PCREL",    /* name */
 372          FALSE,                 /* partial_inplace */
 373          0xffffff,              /* src_mask */
 374          0xffffff,              /* dst_mask */
 375          TRUE),                 /* pcrel_offset */
 376
 377   /* High 20 bits of address when lower 12 is or'd in.  */
 378   HOWTO (R_NDS32_HI20,          /* type */
 379          12,                    /* rightshift */
 380          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 381          20,                    /* bitsize */
 382          FALSE,                 /* pc_relative */
 383          0,                     /* bitpos */
 384          complain_overflow_dont,/* complain_on_overflow */
 385          nds32_elf_hi20_reloc,  /* special_function */
 386          "R_NDS32_HI20",        /* name */
 387          FALSE,                 /* partial_inplace */
 388          0x000fffff,            /* src_mask */
 389          0x000fffff,            /* dst_mask */
 390          FALSE),                /* pcrel_offset */
 391
 392   /* Lower 12 bits of address.  */
 393   HOWTO (R_NDS32_LO12S3,        /* type */
 394          3,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          9,                     /* bitsize */
 397          FALSE,                 /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_dont,/* complain_on_overflow */
 400          nds32_elf_lo12_reloc,  /* special_function */
 401          "R_NDS32_LO12S3",      /* name */
 402          FALSE,                 /* partial_inplace */
 403          0x000001ff,            /* src_mask */
 404          0x000001ff,            /* dst_mask */
 405          FALSE),                /* pcrel_offset */
 406
 407   /* Lower 12 bits of address.  */
 408   HOWTO (R_NDS32_LO12S2,        /* type */
 409          2,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          10,                    /* bitsize */
 412          FALSE,                 /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_dont,/* complain_on_overflow */
 415          nds32_elf_lo12_reloc,  /* special_function */
 416          "R_NDS32_LO12S2",      /* name */
 417          FALSE,                 /* partial_inplace */
 418          0x000003ff,            /* src_mask */
 419          0x000003ff,            /* dst_mask */
 420          FALSE),                /* pcrel_offset */
 421
 422   /* Lower 12 bits of address.  */
 423   HOWTO (R_NDS32_LO12S1,        /* type */
 424          1,                     /* rightshift */
 425          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 426          11,                    /* 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_LO12S1",      /* name */
 432          FALSE,                 /* partial_inplace */
 433          0x000007ff,            /* src_mask */
 434          0x000007ff,            /* dst_mask */
 435          FALSE),                /* pcrel_offset */
 436
 437   /* Lower 12 bits of address.  */
 438   HOWTO (R_NDS32_LO12S0,        /* type */
 439          0,                     /* rightshift */
 440          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 441          12,                    /* 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_LO12S0",      /* name */
 447          FALSE,                 /* partial_inplace */
 448          0x00000fff,            /* src_mask */
 449          0x00000fff,            /* dst_mask */
 450          FALSE),                /* pcrel_offset */
 451
 452   /* Small data area 15 bits offset.  */
 453   HOWTO (R_NDS32_SDA15S3,       /* type */
 454          3,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          15,                    /* bitsize */
 457          FALSE,                 /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed,      /* complain_on_overflow */
 460          nds32_elf_sda15_reloc, /* special_function */
 461          "R_NDS32_SDA15S3",     /* name */
 462          FALSE,                 /* partial_inplace */
 463          0x00007fff,            /* src_mask */
 464          0x00007fff,            /* dst_mask */
 465          FALSE),                /* pcrel_offset */
 466
 467   /* Small data area 15 bits offset.  */
 468   HOWTO (R_NDS32_SDA15S2,       /* type */
 469          2,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          15,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_signed,      /* complain_on_overflow */
 475          nds32_elf_sda15_reloc, /* special_function */
 476          "R_NDS32_SDA15S2",     /* name */
 477          FALSE,                 /* partial_inplace */
 478          0x00007fff,            /* src_mask */
 479          0x00007fff,            /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Small data area 15 bits offset.  */
 483   HOWTO (R_NDS32_SDA15S1,       /* type */
 484          1,                     /* 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_SDA15S1",     /* 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   HOWTO (R_NDS32_SDA15S0,       /* type */
 499          0,                     /* 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_SDA15S0",     /* name */
 507          FALSE,                 /* partial_inplace */
 508          0x00007fff,            /* src_mask */
 509          0x00007fff,            /* dst_mask */
 510          FALSE),                /* pcrel_offset */
 511
 512   /* GNU extension to record C++ vtable hierarchy */
 513   HOWTO (R_NDS32_GNU_VTINHERIT, /* type */
 514          0,                     /* rightshift */
 515          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 516          0,                     /* bitsize */
 517          FALSE,                 /* pc_relative */
 518          0,                     /* bitpos */
 519          complain_overflow_dont,/* complain_on_overflow */
 520          NULL,                  /* special_function */
 521          "R_NDS32_GNU_VTINHERIT",       /* name */
 522          FALSE,                 /* partial_inplace */
 523          0,                     /* src_mask */
 524          0,                     /* dst_mask */
 525          FALSE),                /* pcrel_offset */
 526
 527   /* GNU extension to record C++ vtable member usage */
 528   HOWTO (R_NDS32_GNU_VTENTRY,   /* type */
 529          0,                     /* rightshift */
 530          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          0,                     /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_dont,/* complain_on_overflow */
 535          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 536          "R_NDS32_GNU_VTENTRY", /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0,                     /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* A 16 bit absolute relocation.  */
 543   HOWTO (R_NDS32_16_RELA,       /* type */
 544          0,                     /* rightshift */
 545          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          16,                    /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_bitfield,    /* complain_on_overflow */
 550          bfd_elf_generic_reloc, /* special_function */
 551          "R_NDS32_16_RELA",     /* name */
 552          FALSE,                 /* partial_inplace */
 553          0xffff,                /* src_mask */
 554          0xffff,                /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* A 32 bit absolute relocation.  */
 558   HOWTO (R_NDS32_32_RELA,       /* type */
 559          0,                     /* rightshift */
 560          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 561          32,                    /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_bitfield,    /* complain_on_overflow */
 565          bfd_elf_generic_reloc, /* special_function */
 566          "R_NDS32_32_RELA",     /* name */
 567          FALSE,                 /* partial_inplace */
 568          0xffffffff,            /* src_mask */
 569          0xffffffff,            /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* A 20 bit address.  */
 573   HOWTO (R_NDS32_20_RELA,       /* type */
 574          0,                     /* rightshift */
 575          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 576          20,                    /* bitsize */
 577          FALSE,                 /* pc_relative */
 578          0,                     /* bitpos */
 579          complain_overflow_signed,      /* complain_on_overflow */
 580          bfd_elf_generic_reloc, /* special_function */
 581          "R_NDS32_20_RELA",     /* name */
 582          FALSE,                 /* partial_inplace */
 583          0xfffff,               /* src_mask */
 584          0xfffff,               /* dst_mask */
 585          FALSE),                /* pcrel_offset */
 586
 587   HOWTO (R_NDS32_9_PCREL_RELA,  /* type */
 588          1,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          8,                     /* bitsize */
 591          TRUE,                  /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_signed,      /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_NDS32_9_PCREL_RELA",/* name */
 596          FALSE,                 /* partial_inplace */
 597          0xff,                  /* src_mask */
 598          0xff,                  /* dst_mask */
 599          TRUE),                 /* pcrel_offset */
 600
 601   /* A relative 15 bit relocation, right shifted by 1.  */
 602   HOWTO (R_NDS32_15_PCREL_RELA, /* type */
 603          1,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          14,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          complain_overflow_signed,      /* complain_on_overflow */
 609          bfd_elf_generic_reloc, /* special_function */
 610          "R_NDS32_15_PCREL_RELA",       /* name */
 611          FALSE,                 /* partial_inplace */
 612          0x3fff,                /* src_mask */
 613          0x3fff,                /* dst_mask */
 614          TRUE),                 /* pcrel_offset */
 615
 616   /* A relative 17 bit relocation, right shifted by 1.  */
 617   HOWTO (R_NDS32_17_PCREL_RELA, /* type */
 618          1,                     /* rightshift */
 619          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 620          16,                    /* 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_17_PCREL_RELA",       /* name */
 626          FALSE,                 /* partial_inplace */
 627          0xffff,                /* src_mask */
 628          0xffff,                /* dst_mask */
 629          TRUE),                 /* pcrel_offset */
 630
 631   /* A relative 25 bit relocation, right shifted by 2.  */
 632   HOWTO (R_NDS32_25_PCREL_RELA, /* type */
 633          1,                     /* rightshift */
 634          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 635          24,                    /* 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_25_PCREL_RELA",       /* name */
 641          FALSE,                 /* partial_inplace */
 642          0xffffff,              /* src_mask */
 643          0xffffff,              /* dst_mask */
 644          TRUE),                 /* pcrel_offset */
 645
 646   /* High 20 bits of address when lower 16 is or'd in.  */
 647   HOWTO (R_NDS32_HI20_RELA,     /* type */
 648          12,                    /* rightshift */
 649          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 650          20,                    /* bitsize */
 651          FALSE,                 /* pc_relative */
 652          0,                     /* bitpos */
 653          complain_overflow_dont,/* complain_on_overflow */
 654          bfd_elf_generic_reloc, /* special_function */
 655          "R_NDS32_HI20_RELA",   /* name */
 656          FALSE,                 /* partial_inplace */
 657          0x000fffff,            /* src_mask */
 658          0x000fffff,            /* dst_mask */
 659          FALSE),                /* pcrel_offset */
 660
 661   /* Lower 12 bits of address.  */
 662   HOWTO (R_NDS32_LO12S3_RELA,   /* type */
 663          3,                     /* rightshift */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          9,                     /* bitsize */
 666          FALSE,                 /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_dont,/* complain_on_overflow */
 669          bfd_elf_generic_reloc, /* special_function */
 670          "R_NDS32_LO12S3_RELA", /* name */
 671          FALSE,                 /* partial_inplace */
 672          0x000001ff,            /* src_mask */
 673          0x000001ff,            /* dst_mask */
 674          FALSE),                /* pcrel_offset */
 675
 676   /* Lower 12 bits of address.  */
 677   HOWTO (R_NDS32_LO12S2_RELA,   /* type */
 678          2,                     /* rightshift */
 679          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          10,                    /* 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_LO12S2_RELA", /* name */
 686          FALSE,                 /* partial_inplace */
 687          0x000003ff,            /* src_mask */
 688          0x000003ff,            /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* Lower 12 bits of address.  */
 692   HOWTO (R_NDS32_LO12S1_RELA,   /* type */
 693          1,                     /* rightshift */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          11,                    /* 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_LO12S1_RELA", /* name */
 701          FALSE,                 /* partial_inplace */
 702          0x000007ff,            /* src_mask */
 703          0x000007ff,            /* dst_mask */
 704          FALSE),                /* pcrel_offset */
 705
 706   /* Lower 12 bits of address.  */
 707   HOWTO (R_NDS32_LO12S0_RELA,   /* type */
 708          0,                     /* rightshift */
 709          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 710          12,                    /* 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_LO12S0_RELA", /* name */
 716          FALSE,                 /* partial_inplace */
 717          0x00000fff,            /* src_mask */
 718          0x00000fff,            /* dst_mask */
 719          FALSE),                /* pcrel_offset */
 720
 721   /* Small data area 15 bits offset.  */
 722   HOWTO (R_NDS32_SDA15S3_RELA,  /* type */
 723          3,                     /* rightshift */
 724          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 725          15,                    /* bitsize */
 726          FALSE,                 /* pc_relative */
 727          0,                     /* bitpos */
 728          complain_overflow_signed,      /* complain_on_overflow */
 729          bfd_elf_generic_reloc, /* special_function */
 730          "R_NDS32_SDA15S3_RELA",/* name */
 731          FALSE,                 /* partial_inplace */
 732          0x00007fff,            /* src_mask */
 733          0x00007fff,            /* dst_mask */
 734          FALSE),                /* pcrel_offset */
 735
 736   /* Small data area 15 bits offset.  */
 737   HOWTO (R_NDS32_SDA15S2_RELA,  /* type */
 738          2,                     /* rightshift */
 739          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 740          15,                    /* bitsize */
 741          FALSE,                 /* pc_relative */
 742          0,                     /* bitpos */
 743          complain_overflow_signed,      /* complain_on_overflow */
 744          bfd_elf_generic_reloc, /* special_function */
 745          "R_NDS32_SDA15S2_RELA",/* name */
 746          FALSE,                 /* partial_inplace */
 747          0x00007fff,            /* src_mask */
 748          0x00007fff,            /* dst_mask */
 749          FALSE),                /* pcrel_offset */
 750
 751   HOWTO (R_NDS32_SDA15S1_RELA,  /* type */
 752          1,                     /* rightshift */
 753          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          15,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed,      /* complain_on_overflow */
 758          bfd_elf_generic_reloc, /* special_function */
 759          "R_NDS32_SDA15S1_RELA",/* name */
 760          FALSE,                 /* partial_inplace */
 761          0x00007fff,            /* src_mask */
 762          0x00007fff,            /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   HOWTO (R_NDS32_SDA15S0_RELA,  /* type */
 766          0,                     /* rightshift */
 767          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 768          15,                    /* bitsize */
 769          FALSE,                 /* pc_relative */
 770          0,                     /* bitpos */
 771          complain_overflow_signed,      /* complain_on_overflow */
 772          bfd_elf_generic_reloc, /* special_function */
 773          "R_NDS32_SDA15S0_RELA",/* name */
 774          FALSE,                 /* partial_inplace */
 775          0x00007fff,            /* src_mask */
 776          0x00007fff,            /* dst_mask */
 777          FALSE),                /* pcrel_offset */
 778
 779   /* GNU extension to record C++ vtable hierarchy */
 780   HOWTO (R_NDS32_RELA_GNU_VTINHERIT,    /* type */
 781          0,                     /* rightshift */
 782          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 783          0,                     /* bitsize */
 784          FALSE,                 /* pc_relative */
 785          0,                     /* bitpos */
 786          complain_overflow_dont,/* complain_on_overflow */
 787          NULL,                  /* special_function */
 788          "R_NDS32_RELA_GNU_VTINHERIT",  /* name */
 789          FALSE,                 /* partial_inplace */
 790          0,                     /* src_mask */
 791          0,                     /* dst_mask */
 792          FALSE),                /* pcrel_offset */
 793
 794   /* GNU extension to record C++ vtable member usage */
 795   HOWTO (R_NDS32_RELA_GNU_VTENTRY,      /* type */
 796          0,                     /* rightshift */
 797          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 798          0,                     /* bitsize */
 799          FALSE,                 /* pc_relative */
 800          0,                     /* bitpos */
 801          complain_overflow_dont,/* complain_on_overflow */
 802          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 803          "R_NDS32_RELA_GNU_VTENTRY",    /* name */
 804          FALSE,                 /* partial_inplace */
 805          0,                     /* src_mask */
 806          0,                     /* dst_mask */
 807          FALSE),                /* pcrel_offset */
 808
 809   /* Like R_NDS32_20, but referring to the GOT table entry for
 810      the symbol.  */
 811   HOWTO (R_NDS32_GOT20,         /* type */
 812          0,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          20,                    /* bitsize */
 815          FALSE,                 /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_signed,      /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_NDS32_GOT20",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0xfffff,               /* src_mask */
 822          0xfffff,               /* dst_mask */
 823          FALSE),                /* pcrel_offset */
 824
 825   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
 826      entry for the symbol.  */
 827   HOWTO (R_NDS32_25_PLTREL,     /* type */
 828          1,                     /* rightshift */
 829          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 830          24,                    /* bitsize */
 831          TRUE,                  /* pc_relative */
 832          0,                     /* bitpos */
 833          complain_overflow_signed,      /* complain_on_overflow */
 834          bfd_elf_generic_reloc, /* special_function */
 835          "R_NDS32_25_PLTREL",   /* name */
 836          FALSE,                 /* partial_inplace */
 837          0xffffff,              /* src_mask */
 838          0xffffff,              /* dst_mask */
 839          TRUE),                 /* pcrel_offset */
 840
 841   /* This is used only by the dynamic linker.  The symbol should exist
 842      both in the object being run and in some shared library.  The
 843      dynamic linker copies the data addressed by the symbol from the
 844      shared library into the object, because the object being
 845      run has to have the data at some particular address.  */
 846   HOWTO (R_NDS32_COPY,          /* type */
 847          0,                     /* rightshift */
 848          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          32,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_bitfield,    /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_NDS32_COPY",        /* name */
 855          FALSE,                 /* partial_inplace */
 856          0xffffffff,            /* src_mask */
 857          0xffffffff,            /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* Like R_NDS32_20, but used when setting global offset table
 861      entries.  */
 862   HOWTO (R_NDS32_GLOB_DAT,      /* type */
 863          0,                     /* rightshift */
 864          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          32,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_bitfield,    /* complain_on_overflow */
 869          bfd_elf_generic_reloc, /* special_function */
 870          "R_NDS32_GLOB_DAT",    /* name */
 871          FALSE,                 /* partial_inplace */
 872          0xffffffff,            /* src_mask */
 873          0xffffffff,            /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* Marks a procedure linkage table entry for a symbol.  */
 877   HOWTO (R_NDS32_JMP_SLOT,      /* type */
 878          0,                     /* rightshift */
 879          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          32,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_bitfield,    /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_NDS32_JMP_SLOT",    /* name */
 886          FALSE,                 /* partial_inplace */
 887          0xffffffff,            /* src_mask */
 888          0xffffffff,            /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* Used only by the dynamic linker.  When the object is run, this
 892      longword is set to the load address of the object, plus the
 893      addend.  */
 894   HOWTO (R_NDS32_RELATIVE,      /* type */
 895          0,                     /* rightshift */
 896          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          32,                    /* bitsize */
 898          FALSE,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_bitfield,    /* complain_on_overflow */
 901          bfd_elf_generic_reloc, /* special_function */
 902          "R_NDS32_RELATIVE",    /* name */
 903          FALSE,                 /* partial_inplace */
 904          0xffffffff,            /* src_mask */
 905          0xffffffff,            /* dst_mask */
 906          FALSE),                /* pcrel_offset */
 907
 908   HOWTO (R_NDS32_GOTOFF,        /* type */
 909          0,                     /* rightshift */
 910          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 911          20,                    /* bitsize */
 912          FALSE,                 /* pc_relative */
 913          0,                     /* bitpos */
 914          complain_overflow_signed,      /* complain_on_overflow */
 915          bfd_elf_generic_reloc, /* special_function */
 916          "R_NDS32_GOTOFF",      /* name */
 917          FALSE,                 /* partial_inplace */
 918          0xfffff,               /* src_mask */
 919          0xfffff,               /* dst_mask */
 920          FALSE),                /* pcrel_offset */
 921
 922   /* An PC Relative 20-bit relocation used when setting PIC offset
 923      table register.  */
 924   HOWTO (R_NDS32_GOTPC20,       /* type */
 925          0,                     /* rightshift */
 926          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 927          20,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_signed,      /* complain_on_overflow */
 931          bfd_elf_generic_reloc, /* special_function */
 932          "R_NDS32_GOTPC20",     /* name */
 933          FALSE,                 /* partial_inplace */
 934          0xfffff,               /* src_mask */
 935          0xfffff,               /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* Like R_NDS32_HI20, but referring to the GOT table entry for
 939      the symbol.  */
 940   HOWTO (R_NDS32_GOT_HI20,      /* type */
 941          12,                    /* rightshift */
 942          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 943          20,                    /* bitsize */
 944          FALSE,                 /* pc_relative */
 945          0,                     /* bitpos */
 946          complain_overflow_dont,/* complain_on_overflow */
 947          bfd_elf_generic_reloc, /* special_function */
 948          "R_NDS32_GOT_HI20",    /* name */
 949          FALSE,                 /* partial_inplace */
 950          0x000fffff,            /* src_mask */
 951          0x000fffff,            /* dst_mask */
 952          FALSE),                /* pcrel_offset */
 953   HOWTO (R_NDS32_GOT_LO12,      /* type */
 954          0,                     /* rightshift */
 955          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 956          12,                    /* bitsize */
 957          FALSE,                 /* pc_relative */
 958          0,                     /* bitpos */
 959          complain_overflow_dont,/* complain_on_overflow */
 960          bfd_elf_generic_reloc, /* special_function */
 961          "R_NDS32_GOT_LO12",    /* name */
 962          FALSE,                 /* partial_inplace */
 963          0x00000fff,            /* src_mask */
 964          0x00000fff,            /* dst_mask */
 965          FALSE),                /* pcrel_offset */
 966
 967   /* An PC Relative relocation used when setting PIC offset table register.
 968      Like R_NDS32_HI20, but referring to the GOT table entry for
 969      the symbol.  */
 970   HOWTO (R_NDS32_GOTPC_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_GOTPC_HI20",  /* name */
 979          FALSE,                 /* partial_inplace */
 980          0x000fffff,            /* src_mask */
 981          0x000fffff,            /* dst_mask */
 982          TRUE),                 /* pcrel_offset */
 983   HOWTO (R_NDS32_GOTPC_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_GOTPC_LO12",  /* name */
 992          FALSE,                 /* partial_inplace */
 993          0x00000fff,            /* src_mask */
 994          0x00000fff,            /* dst_mask */
 995          TRUE),                 /* pcrel_offset */
 996
 997   HOWTO (R_NDS32_GOTOFF_HI20,   /* type */
 998          12,                    /* rightshift */
 999          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1000          20,                    /* bitsize */
1001          FALSE,                 /* pc_relative */
1002          0,                     /* bitpos */
1003          complain_overflow_dont,/* complain_on_overflow */
1004          bfd_elf_generic_reloc, /* special_function */
1005          "R_NDS32_GOTOFF_HI20", /* name */
1006          FALSE,                 /* partial_inplace */
1007          0x000fffff,            /* src_mask */
1008          0x000fffff,            /* dst_mask */
1009          FALSE),                /* pcrel_offset */
1010   HOWTO (R_NDS32_GOTOFF_LO12,   /* type */
1011          0,                     /* rightshift */
1012          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1013          12,                    /* bitsize */
1014          FALSE,                 /* pc_relative */
1015          0,                     /* bitpos */
1016          complain_overflow_dont,/* complain_on_overflow */
1017          bfd_elf_generic_reloc, /* special_function */
1018          "R_NDS32_GOTOFF_LO12", /* name */
1019          FALSE,                 /* partial_inplace */
1020          0x00000fff,            /* src_mask */
1021          0x00000fff,            /* dst_mask */
1022          FALSE),                /* pcrel_offset */
1023
1024   /* Alignment hint for relaxable instruction.  This is used with
1025      R_NDS32_LABEL as a pair.  Relax this instruction from 4 bytes to 2
1026      in order to make next label aligned on word boundary.  */
1027   HOWTO (R_NDS32_INSN16,        /* type */
1028          0,                     /* rightshift */
1029          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1030          32,                    /* bitsize */
1031          FALSE,                 /* pc_relative */
1032          0,                     /* bitpos */
1033          complain_overflow_dont,/* complain_on_overflow */
1034          nds32_elf_ignore_reloc,/* special_function */
1035          "R_NDS32_INSN16",      /* name */
1036          FALSE,                 /* partial_inplace */
1037          0x00000fff,            /* src_mask */
1038          0x00000fff,            /* dst_mask */
1039          FALSE),                /* pcrel_offset */
1040
1041   /* Alignment hint for label.  */
1042   HOWTO (R_NDS32_LABEL,         /* type */
1043          0,                     /* rightshift */
1044          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1045          32,                    /* bitsize */
1046          FALSE,                 /* pc_relative */
1047          0,                     /* bitpos */
1048          complain_overflow_dont,/* complain_on_overflow */
1049          nds32_elf_ignore_reloc,/* special_function */
1050          "R_NDS32_LABEL",       /* name */
1051          FALSE,                 /* partial_inplace */
1052          0xffffffff,            /* src_mask */
1053          0xffffffff,            /* dst_mask */
1054          FALSE),                /* pcrel_offset */
1055
1056   /* Relax hint for unconditional call sequence  */
1057   HOWTO (R_NDS32_LONGCALL1,     /* 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_LONGCALL1",   /* name */
1066          FALSE,                 /* partial_inplace */
1067          0xffffffff,            /* src_mask */
1068          0xffffffff,            /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Relax hint for conditional call sequence.  */
1072   HOWTO (R_NDS32_LONGCALL2,     /* 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_LONGCALL2",   /* name */
1081          FALSE,                 /* partial_inplace */
1082          0xffffffff,            /* src_mask */
1083          0xffffffff,            /* dst_mask */
1084          FALSE),                /* pcrel_offset */
1085
1086   /* Relax hint for conditional call sequence.  */
1087   HOWTO (R_NDS32_LONGCALL3,     /* 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_LONGCALL3",   /* name */
1096          FALSE,                 /* partial_inplace */
1097          0xffffffff,            /* src_mask */
1098          0xffffffff,            /* dst_mask */
1099          FALSE),                /* pcrel_offset */
1100
1101   /* Relax hint for unconditional branch sequence.  */
1102   HOWTO (R_NDS32_LONGJUMP1,     /* 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_LONGJUMP1",   /* name */
1111          FALSE,                 /* partial_inplace */
1112          0xffffffff,            /* src_mask */
1113          0xffffffff,            /* dst_mask */
1114          FALSE),                /* pcrel_offset */
1115
1116   /* Relax hint for conditional branch sequence.  */
1117   HOWTO (R_NDS32_LONGJUMP2,     /* 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_LONGJUMP2",   /* name */
1126          FALSE,                 /* partial_inplace */
1127          0xffffffff,            /* src_mask */
1128          0xffffffff,            /* dst_mask */
1129          FALSE),                /* pcrel_offset */
1130
1131   /* Relax hint for conditional branch sequence.  */
1132   HOWTO (R_NDS32_LONGJUMP3,     /* 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_LONGJUMP3",   /* name */
1141          FALSE,                 /* partial_inplace */
1142          0xffffffff,            /* src_mask */
1143          0xffffffff,            /* dst_mask */
1144          FALSE),                /* pcrel_offset */
1145
1146   /* Relax hint for load/store sequence.   */
1147   HOWTO (R_NDS32_LOADSTORE,     /* 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_LOADSTORE",   /* name */
1156          FALSE,                 /* partial_inplace */
1157          0xffffffff,            /* src_mask */
1158          0xffffffff,            /* dst_mask */
1159          FALSE),                /* pcrel_offset */
1160
1161   /* Relax hint for load/store sequence.  */
1162   HOWTO (R_NDS32_9_FIXED_RELA,  /* type */
1163          0,                     /* rightshift */
1164          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1165          16,                    /* 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_9_FIXED_RELA",/* name */
1171          FALSE,                 /* partial_inplace */
1172          0x000000ff,            /* src_mask */
1173          0x000000ff,            /* dst_mask */
1174          FALSE),                /* pcrel_offset */
1175
1176   /* Relax hint for load/store sequence.  */
1177   HOWTO (R_NDS32_15_FIXED_RELA, /* 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_15_FIXED_RELA",       /* name */
1186          FALSE,                 /* partial_inplace */
1187          0x00003fff,            /* src_mask */
1188          0x00003fff,            /* dst_mask */
1189          FALSE),                /* pcrel_offset */
1190
1191   /* Relax hint for load/store sequence.  */
1192   HOWTO (R_NDS32_17_FIXED_RELA, /* type */
1193          0,                     /* rightshift */
1194          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1195          32,                    /* 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_17_FIXED_RELA",       /* name */
1201          FALSE,                 /* partial_inplace */
1202          0x0000ffff,            /* src_mask */
1203          0x0000ffff,            /* dst_mask */
1204          FALSE),                /* pcrel_offset */
1205
1206   /* Relax hint for load/store sequence.  */
1207   HOWTO (R_NDS32_25_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_25_FIXED_RELA",       /* name */
1216          FALSE,                 /* partial_inplace */
1217          0x00ffffff,            /* src_mask */
1218          0x00ffffff,            /* dst_mask */
1219          FALSE),                /* pcrel_offset */
1220
1221   /* High 20 bits of PLT symbol offset relative to PC.  */
1222   HOWTO (R_NDS32_PLTREL_HI20,   /* type */
1223          12,                    /* rightshift */
1224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1225          20,                    /* bitsize */
1226          FALSE,                 /* pc_relative */
1227          0,                     /* bitpos */
1228          complain_overflow_dont,/* complain_on_overflow */
1229          bfd_elf_generic_reloc, /* special_function */
1230          "R_NDS32_PLTREL_HI20", /* name */
1231          FALSE,                 /* partial_inplace */
1232          0x000fffff,            /* src_mask */
1233          0x000fffff,            /* dst_mask */
1234          FALSE),                /* pcrel_offset */
1235
1236   /* Low 12 bits of PLT symbol offset relative to PC.  */
1237   HOWTO (R_NDS32_PLTREL_LO12,   /* type */
1238          0,                     /* rightshift */
1239          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1240          12,                    /* bitsize */
1241          FALSE,                 /* pc_relative */
1242          0,                     /* bitpos */
1243          complain_overflow_dont,/* complain_on_overflow */
1244          bfd_elf_generic_reloc, /* special_function */
1245          "R_NDS32_PLTREL_LO12", /* name */
1246          FALSE,                 /* partial_inplace */
1247          0x00000fff,            /* src_mask */
1248          0x00000fff,            /* dst_mask */
1249          FALSE),                /* pcrel_offset */
1250
1251   /* High 20 bits of PLT symbol offset relative to GOT (GP).  */
1252   HOWTO (R_NDS32_PLT_GOTREL_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_PLT_GOTREL_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 GOT (GP).  */
1267   HOWTO (R_NDS32_PLT_GOTREL_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_PLT_GOTREL_LO12",     /* name */
1276          FALSE,                 /* partial_inplace */
1277          0x00000fff,            /* src_mask */
1278          0x00000fff,            /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   /* Small data area 12 bits offset.  */
1282   HOWTO (R_NDS32_SDA12S2_DP_RELA,       /* type */
1283          2,                     /* rightshift */
1284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1285          12,                    /* bitsize */
1286          FALSE,                 /* pc_relative */
1287          0,                     /* bitpos */
1288          complain_overflow_signed,      /* complain_on_overflow */
1289          bfd_elf_generic_reloc, /* special_function */
1290          "R_NDS32_SDA12S2_DP_RELA",     /* name */
1291          FALSE,                 /* partial_inplace */
1292          0x00000fff,            /* src_mask */
1293          0x00000fff,            /* dst_mask */
1294          FALSE),                /* pcrel_offset */
1295
1296   /* Small data area 12 bits offset.  */
1297   HOWTO (R_NDS32_SDA12S2_SP_RELA,       /* type */
1298          2,                     /* rightshift */
1299          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1300          12,                    /* bitsize */
1301          FALSE,                 /* pc_relative */
1302          0,                     /* bitpos */
1303          complain_overflow_signed,      /* complain_on_overflow */
1304          bfd_elf_generic_reloc, /* special_function */
1305          "R_NDS32_SDA12S2_SP_RELA",     /* name */
1306          FALSE,                 /* partial_inplace */
1307          0x00000fff,            /* src_mask */
1308          0x00000fff,            /* dst_mask */
1309          FALSE),                /* pcrel_offset */
1310   /* Lower 12 bits of address.  */
1311
1312   HOWTO (R_NDS32_LO12S2_DP_RELA,        /* type */
1313          2,                     /* rightshift */
1314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1315          10,                    /* bitsize */
1316          FALSE,                 /* pc_relative */
1317          0,                     /* bitpos */
1318          complain_overflow_dont,/* complain_on_overflow */
1319          bfd_elf_generic_reloc, /* special_function */
1320          "R_NDS32_LO12S2_DP_RELA",      /* name */
1321          FALSE,                 /* partial_inplace */
1322          0x000003ff,            /* src_mask */
1323          0x000003ff,            /* dst_mask */
1324          FALSE),                /* pcrel_offset */
1325
1326   /* Lower 12 bits of address.  */
1327   HOWTO (R_NDS32_LO12S2_SP_RELA,/* type */
1328          2,                     /* rightshift */
1329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1330          10,                    /* bitsize */
1331          FALSE,                 /* pc_relative */
1332          0,                     /* bitpos */
1333          complain_overflow_dont,/* complain_on_overflow */
1334          bfd_elf_generic_reloc, /* special_function */
1335          "R_NDS32_LO12S2_SP_RELA",      /* name */
1336          FALSE,                 /* partial_inplace */
1337          0x000003ff,            /* src_mask */
1338          0x000003ff,            /* dst_mask */
1339          FALSE),                /* pcrel_offset */
1340   /* Lower 12 bits of address.  Special identity for or case.  */
1341   HOWTO (R_NDS32_LO12S0_ORI_RELA,       /* type */
1342          0,                     /* rightshift */
1343          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          12,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont,/* complain_on_overflow */
1348          bfd_elf_generic_reloc, /* special_function */
1349          "R_NDS32_LO12S0_ORI_RELA",     /* name */
1350          FALSE,                 /* partial_inplace */
1351          0x00000fff,            /* src_mask */
1352          0x00000fff,            /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354   /* Small data area 19 bits offset.  */
1355   HOWTO (R_NDS32_SDA16S3_RELA,  /* type */
1356          3,                     /* rightshift */
1357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1358          16,                    /* bitsize */
1359          FALSE,                 /* pc_relative */
1360          0,                     /* bitpos */
1361          complain_overflow_signed,      /* complain_on_overflow */
1362          bfd_elf_generic_reloc, /* special_function */
1363          "R_NDS32_SDA16S3_RELA",/* name */
1364          FALSE,                 /* partial_inplace */
1365          0x0000ffff,            /* src_mask */
1366          0x0000ffff,            /* dst_mask */
1367          FALSE),                /* pcrel_offset */
1368
1369   /* Small data area 15 bits offset.  */
1370   HOWTO (R_NDS32_SDA17S2_RELA,  /* type */
1371          2,                     /* rightshift */
1372          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1373          17,                    /* bitsize */
1374          FALSE,                 /* pc_relative */
1375          0,                     /* bitpos */
1376          complain_overflow_signed,      /* complain_on_overflow */
1377          bfd_elf_generic_reloc, /* special_function */
1378          "R_NDS32_SDA17S2_RELA",/* name */
1379          FALSE,                 /* partial_inplace */
1380          0x0001ffff,            /* src_mask */
1381          0x0001ffff,            /* dst_mask */
1382          FALSE),                /* pcrel_offset */
1383
1384   HOWTO (R_NDS32_SDA18S1_RELA,  /* type */
1385          1,                     /* rightshift */
1386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          18,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed,      /* complain_on_overflow */
1391          bfd_elf_generic_reloc, /* special_function */
1392          "R_NDS32_SDA18S1_RELA",/* name */
1393          FALSE,                 /* partial_inplace */
1394          0x0003ffff,            /* src_mask */
1395          0x0003ffff,            /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   HOWTO (R_NDS32_SDA19S0_RELA,  /* type */
1399          0,                     /* rightshift */
1400          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1401          19,                    /* bitsize */
1402          FALSE,                 /* pc_relative */
1403          0,                     /* bitpos */
1404          complain_overflow_signed,      /* complain_on_overflow */
1405          bfd_elf_generic_reloc, /* special_function */
1406          "R_NDS32_SDA19S0_RELA",/* name */
1407          FALSE,                 /* partial_inplace */
1408          0x0007ffff,            /* src_mask */
1409          0x0007ffff,            /* dst_mask */
1410          FALSE),                /* pcrel_offset */
1411   HOWTO (R_NDS32_DWARF2_OP1_RELA,       /* type */
1412          0,                     /* rightshift */
1413          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1414          8,                     /* bitsize */
1415          FALSE,                 /* pc_relative */
1416          0,                     /* bitpos */
1417          complain_overflow_dont,/* complain_on_overflow */
1418          nds32_elf_ignore_reloc,/* special_function */
1419          "R_NDS32_DWARF2_OP1_RELA",     /* name */
1420          FALSE,                 /* partial_inplace */
1421          0xff,                  /* src_mask */
1422          0xff,                  /* dst_mask */
1423          FALSE),                /* pcrel_offset */
1424   HOWTO (R_NDS32_DWARF2_OP2_RELA,       /* type */
1425          0,                     /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_dont,/* complain_on_overflow */
1431          nds32_elf_ignore_reloc,/* special_function */
1432          "R_NDS32_DWARF2_OP2_RELA",     /* name */
1433          FALSE,                 /* partial_inplace */
1434          0xffff,                /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437   HOWTO (R_NDS32_DWARF2_LEB_RELA,       /* type */
1438          0,                     /* rightshift */
1439          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1440          32,                    /* bitsize */
1441          FALSE,                 /* pc_relative */
1442          0,                     /* bitpos */
1443          complain_overflow_dont,/* complain_on_overflow */
1444          nds32_elf_ignore_reloc,/* special_function */
1445          "R_NDS32_DWARF2_LEB_RELA",     /* name */
1446          FALSE,                 /* partial_inplace */
1447          0xffffffff,            /* src_mask */
1448          0xffffffff,            /* dst_mask */
1449          FALSE),                /* pcrel_offset */
1450   HOWTO (R_NDS32_UPDATE_TA_RELA,/* type */
1451          0,                     /* rightshift */
1452          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1453          16,                    /* bitsize */
1454          FALSE,                 /* pc_relative */
1455          0,                     /* bitpos */
1456          complain_overflow_dont,/* complain_on_overflow */
1457          nds32_elf_ignore_reloc,/* special_function */
1458          "R_NDS32_UPDATE_TA_RELA",      /* name */
1459          FALSE,                 /* partial_inplace */
1460          0xffff,                /* src_mask */
1461          0xffff,                /* dst_mask */
1462          FALSE),                /* pcrel_offset */
1463   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1464      entry for the symbol.  */
1465   HOWTO (R_NDS32_9_PLTREL,      /* type */
1466          1,                     /* rightshift */
1467          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1468          8,                     /* bitsize */
1469          TRUE,                  /* pc_relative */
1470          0,                     /* bitpos */
1471          complain_overflow_signed,      /* complain_on_overflow */
1472          bfd_elf_generic_reloc, /* special_function */
1473          "R_NDS32_9_PLTREL",    /* name */
1474          FALSE,                 /* partial_inplace */
1475          0xff,                  /* src_mask */
1476          0xff,                  /* dst_mask */
1477          TRUE),                 /* pcrel_offset */
1478   /* Low 20 bits of PLT symbol offset relative to GOT (GP).  */
1479   HOWTO (R_NDS32_PLT_GOTREL_LO20,       /* type */
1480          0,                     /* rightshift */
1481          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1482          20,                    /* bitsize */
1483          FALSE,                 /* pc_relative */
1484          0,                     /* bitpos */
1485          complain_overflow_dont,/* complain_on_overflow */
1486          bfd_elf_generic_reloc, /* special_function */
1487          "R_NDS32_PLT_GOTREL_LO20",     /* name */
1488          FALSE,                 /* partial_inplace */
1489          0x000fffff,            /* src_mask */
1490          0x000fffff,            /* dst_mask */
1491          FALSE),                /* pcrel_offset */
1492   /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1493   HOWTO (R_NDS32_PLT_GOTREL_LO15,       /* type */
1494          0,                     /* rightshift */
1495          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          15,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont,/* complain_on_overflow */
1500          bfd_elf_generic_reloc, /* special_function */
1501          "R_NDS32_PLT_GOTREL_LO15",     /* name */
1502          FALSE,                 /* partial_inplace */
1503          0x00007fff,            /* src_mask */
1504          0x00007fff,            /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506   /* Low 19 bits of PLT symbol offset relative to GOT (GP).  */
1507   HOWTO (R_NDS32_PLT_GOTREL_LO19,       /* type */
1508          0,                     /* rightshift */
1509          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          19,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_dont,/* complain_on_overflow */
1514          bfd_elf_generic_reloc, /* special_function */
1515          "R_NDS32_PLT_GOTREL_LO19",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0x0007ffff,            /* src_mask */
1518          0x0007ffff,            /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520   HOWTO (R_NDS32_GOT_LO15,      /* type */
1521          0,                     /* rightshift */
1522          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1523          15,                    /* bitsize */
1524          FALSE,                 /* pc_relative */
1525          0,                     /* bitpos */
1526          complain_overflow_dont,/* complain_on_overflow */
1527          bfd_elf_generic_reloc, /* special_function */
1528          "R_NDS32_GOT_LO15",    /* name */
1529          FALSE,                 /* partial_inplace */
1530          0x00007fff,            /* src_mask */
1531          0x00007fff,            /* dst_mask */
1532          FALSE),                /* pcrel_offset */
1533   HOWTO (R_NDS32_GOT_LO19,      /* type */
1534          0,                     /* rightshift */
1535          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1536          19,                    /* bitsize */
1537          FALSE,                 /* pc_relative */
1538          0,                     /* bitpos */
1539          complain_overflow_dont,/* complain_on_overflow */
1540          bfd_elf_generic_reloc, /* special_function */
1541          "R_NDS32_GOT_LO19",    /* name */
1542          FALSE,                 /* partial_inplace */
1543          0x0007ffff,            /* src_mask */
1544          0x0007ffff,            /* dst_mask */
1545          FALSE),                /* pcrel_offset */
1546   HOWTO (R_NDS32_GOTOFF_LO15,   /* type */
1547          0,                     /* rightshift */
1548          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1549          15,                    /* bitsize */
1550          FALSE,                 /* pc_relative */
1551          0,                     /* bitpos */
1552          complain_overflow_dont,/* complain_on_overflow */
1553          bfd_elf_generic_reloc, /* special_function */
1554          "R_NDS32_GOTOFF_LO15", /* name */
1555          FALSE,                 /* partial_inplace */
1556          0x00007fff,            /* src_mask */
1557          0x00007fff,            /* dst_mask */
1558          FALSE),                /* pcrel_offset */
1559   HOWTO (R_NDS32_GOTOFF_LO19,   /* type */
1560          0,                     /* rightshift */
1561          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1562          19,                    /* bitsize */
1563          FALSE,                 /* pc_relative */
1564          0,                     /* bitpos */
1565          complain_overflow_dont,/* complain_on_overflow */
1566          bfd_elf_generic_reloc, /* special_function */
1567          "R_NDS32_GOTOFF_LO19", /* name */
1568          FALSE,                 /* partial_inplace */
1569          0x0007ffff,            /* src_mask */
1570          0x0007ffff,            /* dst_mask */
1571          FALSE),                /* pcrel_offset */
1572   /* GOT 15 bits offset.  */
1573   HOWTO (R_NDS32_GOT15S2_RELA,  /* type */
1574          2,                     /* rightshift */
1575          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1576          15,                    /* bitsize */
1577          FALSE,                 /* pc_relative */
1578          0,                     /* bitpos */
1579          complain_overflow_signed,      /* complain_on_overflow */
1580          bfd_elf_generic_reloc, /* special_function */
1581          "R_NDS32_GOT15S2_RELA",/* name */
1582          FALSE,                 /* partial_inplace */
1583          0x00007fff,            /* src_mask */
1584          0x00007fff,            /* dst_mask */
1585          FALSE),                /* pcrel_offset */
1586   /* GOT 17 bits offset.  */
1587   HOWTO (R_NDS32_GOT17S2_RELA,  /* type */
1588          2,                     /* rightshift */
1589          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1590          17,                    /* bitsize */
1591          FALSE,                 /* pc_relative */
1592          0,                     /* bitpos */
1593          complain_overflow_signed,      /* complain_on_overflow */
1594          bfd_elf_generic_reloc, /* special_function */
1595          "R_NDS32_GOT17S2_RELA",/* name */
1596          FALSE,                 /* partial_inplace */
1597          0x0001ffff,            /* src_mask */
1598          0x0001ffff,            /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600   /* A 5 bit address.  */
1601   HOWTO (R_NDS32_5_RELA,        /* type */
1602          0,                     /* rightshift */
1603          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1604          5,                     /* bitsize */
1605          FALSE,                 /* pc_relative */
1606          0,                     /* bitpos */
1607          complain_overflow_signed,      /* complain_on_overflow */
1608          bfd_elf_generic_reloc, /* special_function */
1609          "R_NDS32_5_RELA",      /* name */
1610          FALSE,                 /* partial_inplace */
1611          0x1f,                  /* src_mask */
1612          0x1f,                  /* dst_mask */
1613          FALSE),                /* pcrel_offset */
1614   HOWTO (R_NDS32_10_UPCREL_RELA,/* type */
1615          1,                     /* rightshift */
1616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          9,                     /* bitsize */
1618          TRUE,                  /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_unsigned,    /* complain_on_overflow */
1621          bfd_elf_generic_reloc, /* special_function */
1622          "R_NDS32_10_UPCREL_RELA",      /* name */
1623          FALSE,                 /* partial_inplace */
1624          0x1ff,                 /* src_mask */
1625          0x1ff,                 /* dst_mask */
1626          TRUE),                 /* pcrel_offset */
1627   HOWTO (R_NDS32_SDA_FP7U2_RELA,/* type */
1628          2,                     /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          7,                     /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_unsigned,    /* complain_on_overflow */
1634          bfd_elf_generic_reloc, /* special_function */
1635          "R_NDS32_SDA_FP7U2_RELA",      /* name */
1636          FALSE,                 /* partial_inplace */
1637          0x0000007f,            /* src_mask */
1638          0x0000007f,            /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640   HOWTO (R_NDS32_WORD_9_PCREL_RELA,     /* type */
1641          1,                     /* rightshift */
1642          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          8,                     /* bitsize */
1644          TRUE,                  /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_signed,      /* complain_on_overflow */
1647          bfd_elf_generic_reloc, /* special_function */
1648          "R_NDS32_WORD_9_PCREL_RELA",   /* name */
1649          FALSE,                 /* partial_inplace */
1650          0xff,                  /* src_mask */
1651          0xff,                  /* dst_mask */
1652          TRUE),                 /* pcrel_offset */
1653   HOWTO (R_NDS32_25_ABS_RELA,   /* type */
1654          1,                     /* rightshift */
1655          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1656          24,                    /* bitsize */
1657          FALSE,                 /* pc_relative */
1658          0,                     /* bitpos */
1659          complain_overflow_dont,/* complain_on_overflow */
1660          bfd_elf_generic_reloc, /* special_function */
1661          "R_NDS32_25_ABS_RELA", /* name */
1662          FALSE,                 /* partial_inplace */
1663          0xffffff,              /* src_mask */
1664          0xffffff,              /* dst_mask */
1665          FALSE),                /* pcrel_offset */
1666
1667   /* A relative 17 bit relocation for ifc, right shifted by 1.  */
1668   HOWTO (R_NDS32_17IFC_PCREL_RELA,      /* type */
1669          1,                     /* rightshift */
1670          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1671          16,                    /* bitsize */
1672          TRUE,                  /* pc_relative */
1673          0,                     /* bitpos */
1674          complain_overflow_signed,      /* complain_on_overflow */
1675          bfd_elf_generic_reloc, /* special_function */
1676          "R_NDS32_17IFC_PCREL_RELA",    /* name */
1677          FALSE,                 /* partial_inplace */
1678          0xffff,                /* src_mask */
1679          0xffff,                /* dst_mask */
1680          TRUE),                 /* pcrel_offset */
1681
1682   /* A relative unsigned 10 bit relocation for ifc, right shifted by 1.  */
1683   HOWTO (R_NDS32_10IFCU_PCREL_RELA,     /* type */
1684          1,                     /* rightshift */
1685          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1686          9,                     /* bitsize */
1687          TRUE,                  /* pc_relative */
1688          0,                     /* bitpos */
1689          complain_overflow_unsigned,    /* complain_on_overflow */
1690          bfd_elf_generic_reloc, /* special_function */
1691          "R_NDS32_10IFCU_PCREL_RELA",   /* name */
1692          FALSE,                 /* partial_inplace */
1693          0x1ff,                 /* src_mask */
1694          0x1ff,                 /* dst_mask */
1695          TRUE),                 /* pcrel_offset */
1696
1697   /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol.  */
1698   HOWTO (R_NDS32_TLS_LE_HI20,   /* type */
1699          12,                    /* rightshift */
1700          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1701          20,                    /* bitsize */
1702          FALSE,                 /* pc_relative */
1703          0,                     /* bitpos */
1704          complain_overflow_dont,        /* complain_on_overflow */
1705          bfd_elf_generic_reloc, /* special_function */
1706          "R_NDS32_TLS_LE_HI20", /* name */
1707          FALSE,                 /* partial_inplace */
1708          0x000fffff,            /* src_mask */
1709          0x000fffff,            /* dst_mask */
1710          FALSE),                /* pcrel_offset */
1711   HOWTO (R_NDS32_TLS_LE_LO12,   /* type */
1712          0,                     /* rightshift */
1713          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1714          12,                    /* bitsize */
1715          FALSE,                 /* pc_relative */
1716          0,                     /* bitpos */
1717          complain_overflow_dont,        /* complain_on_overflow */
1718          bfd_elf_generic_reloc, /* special_function */
1719          "R_NDS32_TLS_LE_LO12", /* name */
1720          FALSE,                 /* partial_inplace */
1721          0x00000fff,            /* src_mask */
1722          0x00000fff,            /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol.  */
1726   HOWTO (R_NDS32_TLS_IE_HI20,   /* type */
1727          12,                    /* rightshift */
1728          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1729          20,                    /* bitsize */
1730          FALSE,                 /* pc_relative */
1731          0,                     /* bitpos */
1732          complain_overflow_dont,        /* complain_on_overflow */
1733          bfd_elf_generic_reloc, /* special_function */
1734          "R_NDS32_TLS_IE_HI20", /* name */
1735          FALSE,                 /* partial_inplace */
1736          0x000fffff,            /* src_mask */
1737          0x000fffff,            /* dst_mask */
1738          FALSE),                /* pcrel_offset */
1739   HOWTO (R_NDS32_TLS_IE_LO12S2, /* type */
1740          2,                     /* rightshift */
1741          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1742          10,                    /* bitsize */
1743          FALSE,                 /* pc_relative */
1744          0,                     /* bitpos */
1745          complain_overflow_dont,        /* complain_on_overflow */
1746          bfd_elf_generic_reloc, /* special_function */
1747          "R_NDS32_TLS_IE_LO12S2",       /* name */
1748          FALSE,                 /* partial_inplace */
1749          0x000003ff,            /* src_mask */
1750          0x000003ff,            /* dst_mask */
1751          FALSE),                /* pcrel_offset */
1752   /* Mark a TLS IE entry in GOT.  */
1753   HOWTO (R_NDS32_TLS_TPOFF,     /* type */
1754          0,                     /* rightshift */
1755          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1756          32,                    /* bitsize */
1757          FALSE,                 /* pc_relative */
1758          0,                     /* bitpos */
1759          complain_overflow_bitfield,    /* complain_on_overflow */
1760          bfd_elf_generic_reloc, /* special_function */
1761          "R_NDS32_TLS_TPOFF",   /* name */
1762          FALSE,                 /* partial_inplace */
1763          0xffffffff,            /* src_mask */
1764          0xffffffff,            /* dst_mask */
1765          FALSE),                /* pcrel_offset */
1766   /* A 20 bit address.  */
1767   HOWTO (R_NDS32_TLS_LE_20,     /* type */
1768          0,                     /* rightshift */
1769          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          20,                    /* bitsize */
1771          FALSE,         /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed,      /* complain_on_overflow */
1774          bfd_elf_generic_reloc, /* special_function */
1775          "R_NDS32_TLS_LE_20",   /* name */
1776          FALSE,         /* partial_inplace */
1777          0xfffff,               /* src_mask */
1778          0xfffff,               /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780   HOWTO (R_NDS32_TLS_LE_15S0,   /* type */
1781          0,                     /* rightshift */
1782          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1783          15,                    /* bitsize */
1784          FALSE,         /* pc_relative */
1785          0,                     /* bitpos */
1786          complain_overflow_signed,      /* complain_on_overflow */
1787          bfd_elf_generic_reloc, /* special_function */
1788          "R_NDS32_TLS_LE_15S0", /* name */
1789          FALSE,         /* partial_inplace */
1790          0x7fff,                /* src_mask */
1791          0x7fff,                /* dst_mask */
1792          FALSE),                /* pcrel_offset */
1793   HOWTO (R_NDS32_TLS_LE_15S1,   /* type */
1794          1,                     /* rightshift */
1795          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1796          15,                    /* bitsize */
1797          FALSE,         /* pc_relative */
1798          0,                     /* bitpos */
1799          complain_overflow_signed,      /* complain_on_overflow */
1800          bfd_elf_generic_reloc, /* special_function */
1801          "R_NDS32_TLS_LE_15S1", /* name */
1802          FALSE,         /* partial_inplace */
1803          0x7fff,                /* src_mask */
1804          0x7fff,                /* dst_mask */
1805          FALSE),                /* pcrel_offset */
1806   HOWTO (R_NDS32_TLS_LE_15S2,   /* type */
1807          2,                     /* rightshift */
1808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1809          15,                    /* bitsize */
1810          FALSE,         /* pc_relative */
1811          0,                     /* bitpos */
1812          complain_overflow_signed,      /* complain_on_overflow */
1813          bfd_elf_generic_reloc, /* special_function */
1814          "R_NDS32_TLS_LE_15S2", /* name */
1815          FALSE,         /* partial_inplace */
1816          0x7fff,                /* src_mask */
1817          0x7fff,                /* dst_mask */
1818          FALSE),                /* pcrel_offset */
1819
1820   /* Relax hint for unconditional call sequence  */
1821   HOWTO (R_NDS32_LONGCALL4,     /* type */
1822          0,                     /* rightshift */
1823          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1824          32,                    /* bitsize */
1825          FALSE,                 /* pc_relative */
1826          0,                     /* bitpos */
1827          complain_overflow_dont,        /* complain_on_overflow */
1828          nds32_elf_ignore_reloc,        /* special_function */
1829          "R_NDS32_LONGCALL4",   /* name */
1830          FALSE,                 /* partial_inplace */
1831          0xffffffff,            /* src_mask */
1832          0xffffffff,            /* dst_mask */
1833          FALSE),                /* pcrel_offset */
1834
1835   /* Relax hint for conditional call sequence.  */
1836   HOWTO (R_NDS32_LONGCALL5,     /* type */
1837          0,                     /* rightshift */
1838          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1839          32,                    /* bitsize */
1840          FALSE,                 /* pc_relative */
1841          0,                     /* bitpos */
1842          complain_overflow_dont,        /* complain_on_overflow */
1843          nds32_elf_ignore_reloc,        /* special_function */
1844          "R_NDS32_LONGCALL5",   /* name */
1845          FALSE,                 /* partial_inplace */
1846          0xffffffff,            /* src_mask */
1847          0xffffffff,            /* dst_mask */
1848          FALSE),                /* pcrel_offset */
1849
1850   /* Relax hint for conditional call sequence.  */
1851   HOWTO (R_NDS32_LONGCALL6,     /* type */
1852          0,                     /* rightshift */
1853          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1854          32,                    /* bitsize */
1855          FALSE,                 /* pc_relative */
1856          0,                     /* bitpos */
1857          complain_overflow_dont,        /* complain_on_overflow */
1858          nds32_elf_ignore_reloc,        /* special_function */
1859          "R_NDS32_LONGCALL6",   /* name */
1860          FALSE,                 /* partial_inplace */
1861          0xffffffff,            /* src_mask */
1862          0xffffffff,            /* dst_mask */
1863          FALSE),                /* pcrel_offset */
1864
1865   /* Relax hint for unconditional branch sequence.  */
1866   HOWTO (R_NDS32_LONGJUMP4,     /* type */
1867          0,                     /* rightshift */
1868          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1869          32,                    /* bitsize */
1870          FALSE,                 /* pc_relative */
1871          0,                     /* bitpos */
1872          complain_overflow_dont,        /* complain_on_overflow */
1873          nds32_elf_ignore_reloc,        /* special_function */
1874          "R_NDS32_LONGJUMP4",   /* name */
1875          FALSE,                 /* partial_inplace */
1876          0xffffffff,            /* src_mask */
1877          0xffffffff,            /* dst_mask */
1878          FALSE),                /* pcrel_offset */
1879
1880   /* Relax hint for conditional branch sequence.  */
1881   HOWTO (R_NDS32_LONGJUMP5,     /* type */
1882          0,                     /* rightshift */
1883          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          32,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_dont,        /* complain_on_overflow */
1888          nds32_elf_ignore_reloc,        /* special_function */
1889          "R_NDS32_LONGJUMP5",   /* name */
1890          FALSE,                 /* partial_inplace */
1891          0xffffffff,            /* src_mask */
1892          0xffffffff,            /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Relax hint for conditional branch sequence.  */
1896   HOWTO (R_NDS32_LONGJUMP6,     /* type */
1897          0,                     /* rightshift */
1898          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          32,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont,        /* complain_on_overflow */
1903          nds32_elf_ignore_reloc,        /* special_function */
1904          "R_NDS32_LONGJUMP6",   /* name */
1905          FALSE,                 /* partial_inplace */
1906          0xffffffff,            /* src_mask */
1907          0xffffffff,            /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Relax hint for conditional branch sequence.  */
1911   HOWTO (R_NDS32_LONGJUMP7,     /* type */
1912          0,                     /* rightshift */
1913          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          32,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_dont,        /* complain_on_overflow */
1918          nds32_elf_ignore_reloc,        /* special_function */
1919          "R_NDS32_LONGJUMP7",   /* name */
1920          FALSE,                 /* partial_inplace */
1921          0xffffffff,            /* src_mask */
1922          0xffffffff,            /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924 };
1925
1926 /* Relocations used for relaxation.  */
1927 static reloc_howto_type nds32_elf_relax_howto_table[] =
1928 {
1929   HOWTO (R_NDS32_RELAX_ENTRY,   /* type */
1930          0,                     /* rightshift */
1931          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1932          32,                    /* bitsize */
1933          FALSE,                 /* pc_relative */
1934          0,                     /* bitpos */
1935          complain_overflow_dont,/* complain_on_overflow */
1936          nds32_elf_ignore_reloc,/* special_function */
1937          "R_NDS32_RELAX_ENTRY", /* name */
1938          FALSE,                 /* partial_inplace */
1939          0xffffffff,            /* src_mask */
1940          0xffffffff,            /* dst_mask */
1941          FALSE),                /* pcrel_offset */
1942   HOWTO (R_NDS32_GOT_SUFF,      /* type */
1943          0,                     /* rightshift */
1944          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1945          32,                    /* bitsize */
1946          FALSE,                 /* pc_relative */
1947          0,                     /* bitpos */
1948          complain_overflow_dont,/* complain_on_overflow */
1949          nds32_elf_ignore_reloc,/* special_function */
1950          "R_NDS32_GOT_SUFF",    /* name */
1951          FALSE,                 /* partial_inplace */
1952          0xffffffff,            /* src_mask */
1953          0xffffffff,            /* dst_mask */
1954          FALSE),                /* pcrel_offset */
1955   HOWTO (R_NDS32_GOTOFF_SUFF,   /* type */
1956          0,                     /* rightshift */
1957          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1958          32,                    /* bitsize */
1959          FALSE,                 /* pc_relative */
1960          0,                     /* bitpos */
1961          complain_overflow_bitfield,    /* complain_on_overflow */
1962          nds32_elf_ignore_reloc,/* special_function */
1963          "R_NDS32_GOTOFF_SUFF", /* name */
1964          FALSE,                 /* partial_inplace */
1965          0xffffffff,            /* src_mask */
1966          0xffffffff,            /* dst_mask */
1967          FALSE),                /* pcrel_offset */
1968   HOWTO (R_NDS32_PLT_GOT_SUFF,  /* type */
1969          0,                     /* rightshift */
1970          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1971          32,                    /* bitsize */
1972          FALSE,                 /* pc_relative */
1973          0,                     /* bitpos */
1974          complain_overflow_dont,/* complain_on_overflow */
1975          nds32_elf_ignore_reloc,/* special_function */
1976          "R_NDS32_PLT_GOT_SUFF",/* name */
1977          FALSE,                 /* partial_inplace */
1978          0xffffffff,            /* src_mask */
1979          0xffffffff,            /* dst_mask */
1980          FALSE),                /* pcrel_offset */
1981   HOWTO (R_NDS32_MULCALL_SUFF,  /* type */
1982          0,                     /* rightshift */
1983          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1984          32,                    /* bitsize */
1985          FALSE,                 /* pc_relative */
1986          0,                     /* bitpos */
1987          complain_overflow_dont,/* complain_on_overflow */
1988          nds32_elf_ignore_reloc,/* special_function */
1989          "R_NDS32_MULCALL_SUFF",/* name */
1990          FALSE,                 /* partial_inplace */
1991          0xffffffff,            /* src_mask */
1992          0xffffffff,            /* dst_mask */
1993          FALSE),                /* pcrel_offset */
1994   HOWTO (R_NDS32_PTR,           /* type */
1995          0,                     /* rightshift */
1996          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1997          32,                    /* bitsize */
1998          FALSE,                 /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_dont,/* complain_on_overflow */
2001          nds32_elf_ignore_reloc,/* special_function */
2002          "R_NDS32_PTR",         /* name */
2003          FALSE,                 /* partial_inplace */
2004          0xffffffff,            /* src_mask */
2005          0xffffffff,            /* dst_mask */
2006          FALSE),                /* pcrel_offset */
2007   HOWTO (R_NDS32_PTR_COUNT,     /* type */
2008          0,                     /* rightshift */
2009          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          32,                    /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont,/* complain_on_overflow */
2014          nds32_elf_ignore_reloc,/* special_function */
2015          "R_NDS32_PTR_COUNT",   /* name */
2016          FALSE,                 /* partial_inplace */
2017          0xffffffff,            /* src_mask */
2018          0xffffffff,            /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020   HOWTO (R_NDS32_PTR_RESOLVED,  /* type */
2021          0,                     /* rightshift */
2022          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          32,                    /* bitsize */
2024          FALSE,                 /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_dont,/* complain_on_overflow */
2027          nds32_elf_ignore_reloc,/* special_function */
2028          "R_NDS32_PTR_RESOLVED",/* name */
2029          FALSE,                 /* partial_inplace */
2030          0xffffffff,            /* src_mask */
2031          0xffffffff,            /* dst_mask */
2032          FALSE),                /* pcrel_offset */
2033   HOWTO (R_NDS32_PLTBLOCK,      /* type */
2034          0,                     /* rightshift */
2035          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2036          32,                    /* bitsize */
2037          FALSE,                 /* pc_relative */
2038          0,                     /* bitpos */
2039          complain_overflow_dont,/* complain_on_overflow */
2040          nds32_elf_ignore_reloc,/* special_function */
2041          "R_NDS32_PLTBLOCK",    /* name */
2042          FALSE,                 /* partial_inplace */
2043          0xffffffff,            /* src_mask */
2044          0xffffffff,            /* dst_mask */
2045          FALSE),                /* pcrel_offset */
2046   HOWTO (R_NDS32_RELAX_REGION_BEGIN,    /* type */
2047          0,                     /* rightshift */
2048          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2049          32,                    /* bitsize */
2050          FALSE,                 /* pc_relative */
2051          0,                     /* bitpos */
2052          complain_overflow_dont,/* complain_on_overflow */
2053          nds32_elf_ignore_reloc,/* special_function */
2054          "R_NDS32_RELAX_REGION_BEGIN",  /* name */
2055          FALSE,                 /* partial_inplace */
2056          0xffffffff,            /* src_mask */
2057          0xffffffff,            /* dst_mask */
2058          FALSE),                /* pcrel_offset */
2059   HOWTO (R_NDS32_RELAX_REGION_END,      /* type */
2060          0,                     /* rightshift */
2061          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2062          32,                    /* bitsize */
2063          FALSE,                 /* pc_relative */
2064          0,                     /* bitpos */
2065          complain_overflow_dont,/* complain_on_overflow */
2066          nds32_elf_ignore_reloc,/* special_function */
2067          "R_NDS32_RELAX_REGION_END",    /* name */
2068          FALSE,                 /* partial_inplace */
2069          0xffffffff,            /* src_mask */
2070          0xffffffff,            /* dst_mask */
2071          FALSE),                /* pcrel_offset */
2072   HOWTO (R_NDS32_MINUEND,       /* type */
2073          0,                     /* rightshift */
2074          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2075          32,                    /* bitsize */
2076          FALSE,                 /* pc_relative */
2077          0,                     /* bitpos */
2078          complain_overflow_dont,/* complain_on_overflow */
2079          nds32_elf_ignore_reloc,/* special_function */
2080          "R_NDS32_MINUEND",     /* name */
2081          FALSE,                 /* partial_inplace */
2082          0xffffffff,            /* src_mask */
2083          0xffffffff,            /* dst_mask */
2084          FALSE),                /* pcrel_offset */
2085   HOWTO (R_NDS32_SUBTRAHEND,    /* type */
2086          0,                     /* rightshift */
2087          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2088          32,                    /* bitsize */
2089          FALSE,                 /* pc_relative */
2090          0,                     /* bitpos */
2091          complain_overflow_dont,/* complain_on_overflow */
2092          nds32_elf_ignore_reloc,/* special_function */
2093          "R_NDS32_SUBTRAHEND",  /* name */
2094          FALSE,                 /* partial_inplace */
2095          0xffffffff,            /* src_mask */
2096          0xffffffff,            /* dst_mask */
2097          FALSE),                /* pcrel_offset */
2098   HOWTO (R_NDS32_DIFF8,         /* type */
2099          0,                     /* rightshift */
2100          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2101          8,                     /* bitsize */
2102          FALSE,                 /* pc_relative */
2103          0,                     /* bitpos */
2104          complain_overflow_dont,/* complain_on_overflow */
2105          nds32_elf_ignore_reloc,/* special_function */
2106          "R_NDS32_DIFF8",       /* name */
2107          FALSE,                 /* partial_inplace */
2108          0x000000ff,            /* src_mask */
2109          0x000000ff,            /* dst_mask */
2110          FALSE),                /* pcrel_offset */
2111   HOWTO (R_NDS32_DIFF16,        /* type */
2112          0,                     /* rightshift */
2113          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2114          16,                    /* bitsize */
2115          FALSE,                 /* pc_relative */
2116          0,                     /* bitpos */
2117          complain_overflow_dont,/* complain_on_overflow */
2118          nds32_elf_ignore_reloc,/* special_function */
2119          "R_NDS32_DIFF16",      /* name */
2120          FALSE,                 /* partial_inplace */
2121          0x0000ffff,            /* src_mask */
2122          0x0000ffff,            /* dst_mask */
2123          FALSE),                /* pcrel_offset */
2124   HOWTO (R_NDS32_DIFF32,        /* type */
2125          0,                     /* rightshift */
2126          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2127          32,                    /* bitsize */
2128          FALSE,                 /* pc_relative */
2129          0,                     /* bitpos */
2130          complain_overflow_dont,/* complain_on_overflow */
2131          nds32_elf_ignore_reloc,/* special_function */
2132          "R_NDS32_DIFF32",      /* name */
2133          FALSE,                 /* partial_inplace */
2134          0xffffffff,            /* src_mask */
2135          0xffffffff,            /* dst_mask */
2136          FALSE),                /* pcrel_offset */
2137   HOWTO (R_NDS32_DIFF_ULEB128,  /* type */
2138          0,                     /* rightshift */
2139          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2140          0,                     /* bitsize */
2141          FALSE,                 /* pc_relative */
2142          0,                     /* bitpos */
2143          complain_overflow_dont,/* complain_on_overflow */
2144          nds32_elf_ignore_reloc,/* special_function */
2145          "R_NDS32_DIFF_ULEB128",/* name */
2146          FALSE,                 /* partial_inplace */
2147          0xffffffff,            /* src_mask */
2148          0xffffffff,            /* dst_mask */
2149          FALSE),                /* pcrel_offset */
2150   HOWTO (R_NDS32_DATA,          /* type */
2151          0,                     /* rightshift */
2152          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2153          32,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont,/* complain_on_overflow */
2157          nds32_elf_ignore_reloc,/* special_function */
2158          "R_NDS32_DATA",        /* name */
2159          FALSE,                 /* partial_inplace */
2160          0xffffffff,            /* src_mask */
2161          0xffffffff,            /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163   HOWTO (R_NDS32_TRAN,          /* type */
2164          0,                     /* rightshift */
2165          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2166          32,                    /* bitsize */
2167          FALSE,                 /* pc_relative */
2168          0,                     /* bitpos */
2169          complain_overflow_dont,/* complain_on_overflow */
2170          nds32_elf_ignore_reloc,/* special_function */
2171          "R_NDS32_TRAN",        /* name */
2172          FALSE,                 /* partial_inplace */
2173          0xffffffff,            /* src_mask */
2174          0xffffffff,            /* dst_mask */
2175          FALSE),                /* pcrel_offset */
2176   HOWTO (R_NDS32_TLS_LE_ADD,    /* type */
2177          0,                     /* rightshift */
2178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2179          32,                    /* bitsize */
2180          FALSE,                 /* pc_relative */
2181          0,                     /* bitpos */
2182          complain_overflow_dont,        /* complain_on_overflow */
2183          nds32_elf_ignore_reloc,        /* special_function */
2184          "R_NDS32_TLS_LE_ADD",  /* name */
2185          FALSE,                 /* partial_inplace */
2186          0xffffffff,            /* src_mask */
2187          0xffffffff,            /* dst_mask */
2188          FALSE),                /* pcrel_offset */
2189   HOWTO (R_NDS32_TLS_LE_LS,     /* type */
2190          0,                     /* rightshift */
2191          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2192          32,                    /* bitsize */
2193          FALSE,                 /* pc_relative */
2194          0,                     /* bitpos */
2195          complain_overflow_dont,        /* complain_on_overflow */
2196          nds32_elf_ignore_reloc,        /* special_function */
2197          "R_NDS32_TLS_LE_LS",   /* name */
2198          FALSE,                 /* partial_inplace */
2199          0xffffffff,            /* src_mask */
2200          0xffffffff,            /* dst_mask */
2201          FALSE),                /* pcrel_offset */
2202   HOWTO (R_NDS32_EMPTY,         /* type */
2203          0,                     /* rightshift */
2204          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2205          32,                    /* bitsize */
2206          FALSE,                 /* pc_relative */
2207          0,                     /* bitpos */
2208          complain_overflow_dont,        /* complain_on_overflow */
2209          nds32_elf_ignore_reloc,        /* special_function */
2210          "R_NDS32_EMPTY",               /* name */
2211          FALSE,                 /* partial_inplace */
2212          0xffffffff,            /* src_mask */
2213          0xffffffff,            /* dst_mask */
2214          FALSE),                /* pcrel_offset */
2215 };
2216
2217 \f
2218 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2219    This prototype is the same as qsort ().  */
2220
2221 void
2222 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2223                       int (*compar) (const void *lhs, const void *rhs))
2224 {
2225   char *ptr = (char *) base;
2226   int i, j;
2227   char *tmp = xmalloc (size);
2228
2229   /* If i is less than j, i is inserted before j.
2230
2231      |---- j ----- i --------------|
2232       \          / \              /
2233          sorted         unsorted
2234    */
2235
2236   for (i = 1; i < (int) nmemb; i++)
2237     {
2238       for (j = (i - 1); j >= 0; j--)
2239         if (compar (ptr + i * size, ptr + j * size) >= 0)
2240           break;
2241
2242       j++;
2243
2244       if (i == j)
2245         continue; /* i is in order.  */
2246
2247       memcpy (tmp, ptr + i * size, size);
2248       memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2249       memcpy (ptr + j * size, tmp, size);
2250     }
2251   free (tmp);
2252 }
2253
2254 /* Sort relocation by r_offset.
2255
2256    We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2257    algorithm.  Relocations at the same r_offset must keep their order.
2258    For example, RELAX_ENTRY must be the very first relocation entry.
2259
2260    Currently, this function implements insertion-sort.
2261
2262    FIXME: If we already sort them in assembler, why bother sort them
2263           here again?  */
2264
2265 static int
2266 compar_reloc (const void *lhs, const void *rhs)
2267 {
2268   const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2269   const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2270
2271   if (l->r_offset > r->r_offset)
2272     return 1;
2273   else if (l->r_offset == r->r_offset)
2274     return 0;
2275   else
2276     return -1;
2277 }
2278
2279 /* Functions listed below are only used for old relocs.
2280    * nds32_elf_9_pcrel_reloc
2281    * nds32_elf_do_9_pcrel_reloc
2282    * nds32_elf_hi20_reloc
2283    * nds32_elf_relocate_hi20
2284    * nds32_elf_lo12_reloc
2285    * nds32_elf_sda15_reloc
2286    * nds32_elf_generic_reloc
2287    */
2288
2289 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc.  */
2290
2291 static bfd_reloc_status_type
2292 nds32_elf_9_pcrel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2293                          void *data, asection *input_section, bfd *output_bfd,
2294                          char **error_message ATTRIBUTE_UNUSED)
2295 {
2296   /* This part is from bfd_elf_generic_reloc.  */
2297   if (output_bfd != (bfd *) NULL
2298       && (symbol->flags & BSF_SECTION_SYM) == 0
2299       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2300     {
2301       reloc_entry->address += input_section->output_offset;
2302       return bfd_reloc_ok;
2303     }
2304
2305   if (output_bfd != NULL)
2306     {
2307       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2308       return bfd_reloc_continue;
2309     }
2310
2311   return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2312                                      input_section,
2313                                      data, reloc_entry->address,
2314                                      symbol->section,
2315                                      (symbol->value
2316                                       + symbol->section->output_section->vma
2317                                       + symbol->section->output_offset),
2318                                      reloc_entry->addend);
2319 }
2320
2321 /* Utility to actually perform an R_NDS32_9_PCREL reloc.  */
2322 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2323
2324 static bfd_reloc_status_type
2325 nds32_elf_do_9_pcrel_reloc (bfd *abfd, reloc_howto_type *howto,
2326                             asection *input_section, bfd_byte *data,
2327                             bfd_vma offset,
2328                             asection *symbol_section ATTRIBUTE_UNUSED,
2329                             bfd_vma symbol_value, bfd_vma addend)
2330 {
2331   bfd_signed_vma relocation;
2332   unsigned short x;
2333   bfd_reloc_status_type status;
2334
2335   /* Sanity check the address (offset in section).  */
2336   if (offset > bfd_get_section_limit (abfd, input_section))
2337     return bfd_reloc_outofrange;
2338
2339   relocation = symbol_value + addend;
2340   /* Make it pc relative.  */
2341   relocation -= (input_section->output_section->vma
2342                  + input_section->output_offset);
2343   /* These jumps mask off the lower two bits of the current address
2344      before doing pcrel calculations.  */
2345   relocation -= (offset & -(bfd_vma) 2);
2346
2347   if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2348     status = bfd_reloc_overflow;
2349   else
2350     status = bfd_reloc_ok;
2351
2352   x = bfd_getb16 (data + offset);
2353
2354   relocation >>= howto->rightshift;
2355   relocation <<= howto->bitpos;
2356   x = (x & ~howto->dst_mask)
2357       | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2358
2359   bfd_putb16 ((bfd_vma) x, data + offset);
2360
2361   return status;
2362 }
2363
2364 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2365    HI20_SLO is for the add3 and load/store with displacement instructions.
2366    HI20 is for the or3 instruction.
2367    For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2368    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2369    we must add one to the high 16 bytes (which will get subtracted off when
2370    the low 16 bits are added).
2371    These relocs have to be done in combination with an R_NDS32_LO12 reloc
2372    because there is a carry from the LO12 to the HI20.  Here we just save
2373    the information we need; we do the actual relocation when we see the LO12.
2374    This code is copied from the elf32-mips.c.  We also support an arbitrary
2375    number of HI20 relocs to be associated with a single LO12 reloc.  The
2376    assembler sorts the relocs to ensure each HI20 immediately precedes its
2377    LO12.  However if there are multiple copies, the assembler may not find
2378    the real LO12 so it picks the first one it finds.  */
2379
2380 struct nds32_hi20
2381 {
2382   struct nds32_hi20 *next;
2383   bfd_byte *addr;
2384   bfd_vma addend;
2385 };
2386
2387 static struct nds32_hi20 *nds32_hi20_list;
2388
2389 static bfd_reloc_status_type
2390 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2391                       asymbol *symbol, void *data, asection *input_section,
2392                       bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2393 {
2394   bfd_reloc_status_type ret;
2395   bfd_vma relocation;
2396   struct nds32_hi20 *n;
2397
2398   /* This part is from bfd_elf_generic_reloc.
2399      If we're relocating, and this an external symbol, we don't want
2400      to change anything.  */
2401   if (output_bfd != (bfd *) NULL
2402       && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2403     {
2404       reloc_entry->address += input_section->output_offset;
2405       return bfd_reloc_ok;
2406     }
2407
2408   /* Sanity check the address (offset in section).  */
2409   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2410     return bfd_reloc_outofrange;
2411
2412   ret = bfd_reloc_ok;
2413   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2414     ret = bfd_reloc_undefined;
2415
2416   if (bfd_is_com_section (symbol->section))
2417     relocation = 0;
2418   else
2419     relocation = symbol->value;
2420
2421   relocation += symbol->section->output_section->vma;
2422   relocation += symbol->section->output_offset;
2423   relocation += reloc_entry->addend;
2424
2425   /* Save the information, and let LO12 do the actual relocation.  */
2426   n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2427   if (n == NULL)
2428     return bfd_reloc_outofrange;
2429
2430   n->addr = (bfd_byte *) data + reloc_entry->address;
2431   n->addend = relocation;
2432   n->next = nds32_hi20_list;
2433   nds32_hi20_list = n;
2434
2435   if (output_bfd != (bfd *) NULL)
2436     reloc_entry->address += input_section->output_offset;
2437
2438   return ret;
2439 }
2440
2441 /* Handle an NDS32 ELF HI20 reloc.  */
2442
2443 static void
2444 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2445                          int type ATTRIBUTE_UNUSED, Elf_Internal_Rela *relhi,
2446                          Elf_Internal_Rela *rello, bfd_byte *contents,
2447                          bfd_vma addend)
2448 {
2449   unsigned long insn;
2450   bfd_vma addlo;
2451
2452   insn = bfd_getb32 (contents + relhi->r_offset);
2453
2454   addlo = bfd_getb32 (contents + rello->r_offset);
2455   addlo &= 0xfff;
2456
2457   addend += ((insn & 0xfffff) << 20) + addlo;
2458
2459   insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2460   bfd_putb32 (insn, contents + relhi->r_offset);
2461 }
2462
2463 /* Do an R_NDS32_LO12 relocation.  This is a straightforward 12 bit
2464    inplace relocation; this function exists in order to do the
2465    R_NDS32_HI20_[SU]LO relocation described above.  */
2466
2467 static bfd_reloc_status_type
2468 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2469                       void *data, asection *input_section, bfd *output_bfd,
2470                       char **error_message)
2471 {
2472   /* This part is from bfd_elf_generic_reloc.
2473      If we're relocating, and this an external symbol, we don't want
2474      to change anything.  */
2475   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2476       && reloc_entry->addend == 0)
2477     {
2478       reloc_entry->address += input_section->output_offset;
2479       return bfd_reloc_ok;
2480     }
2481
2482   if (nds32_hi20_list != NULL)
2483     {
2484       struct nds32_hi20 *l;
2485
2486       l = nds32_hi20_list;
2487       while (l != NULL)
2488         {
2489           unsigned long insn;
2490           unsigned long val;
2491           unsigned long vallo;
2492           struct nds32_hi20 *next;
2493
2494           /* Do the HI20 relocation.  Note that we actually don't need
2495              to know anything about the LO12 itself, except where to
2496              find the low 12 bits of the addend needed by the LO12.  */
2497           insn = bfd_getb32 (l->addr);
2498           vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2499           vallo &= 0xfff;
2500           switch (reloc_entry->howto->type)
2501             {
2502             case R_NDS32_LO12S3:
2503               vallo <<= 3;
2504               break;
2505
2506             case R_NDS32_LO12S2:
2507               vallo <<= 2;
2508               break;
2509
2510             case R_NDS32_LO12S1:
2511               vallo <<= 1;
2512               break;
2513
2514             case R_NDS32_LO12S0:
2515               vallo <<= 0;
2516               break;
2517             }
2518
2519           val = ((insn & 0xfffff) << 12) + vallo;
2520           val += l->addend;
2521
2522           insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2523           bfd_putb32 ((bfd_vma) insn, l->addr);
2524
2525           next = l->next;
2526           free (l);
2527           l = next;
2528         }
2529
2530       nds32_hi20_list = NULL;
2531     }
2532
2533   /* Now do the LO12 reloc in the usual way.
2534      ??? It would be nice to call bfd_elf_generic_reloc here,
2535      but we have partial_inplace set.  bfd_elf_generic_reloc will
2536      pass the handling back to bfd_install_relocation which will install
2537      a section relative addend which is wrong.  */
2538   return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2539                                   input_section, output_bfd, error_message);
2540 }
2541
2542 /* Do generic partial_inplace relocation.
2543    This is a local replacement for bfd_elf_generic_reloc.  */
2544
2545 static bfd_reloc_status_type
2546 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2547                          asymbol *symbol, void *data, asection *input_section,
2548                          bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2549 {
2550   bfd_reloc_status_type ret;
2551   bfd_vma relocation;
2552   bfd_byte *inplace_address;
2553
2554   /* This part is from bfd_elf_generic_reloc.
2555      If we're relocating, and this an external symbol, we don't want
2556      to change anything.  */
2557   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2558       && reloc_entry->addend == 0)
2559     {
2560       reloc_entry->address += input_section->output_offset;
2561       return bfd_reloc_ok;
2562     }
2563
2564   /* Now do the reloc in the usual way.
2565      ??? It would be nice to call bfd_elf_generic_reloc here,
2566      but we have partial_inplace set.  bfd_elf_generic_reloc will
2567      pass the handling back to bfd_install_relocation which will install
2568      a section relative addend which is wrong.  */
2569
2570   /* Sanity check the address (offset in section).  */
2571   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2572     return bfd_reloc_outofrange;
2573
2574   ret = bfd_reloc_ok;
2575   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2576     ret = bfd_reloc_undefined;
2577
2578   if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2579     relocation = 0;
2580   else
2581     relocation = symbol->value;
2582
2583   /* Only do this for a final link.  */
2584   if (output_bfd == (bfd *) NULL)
2585     {
2586       relocation += symbol->section->output_section->vma;
2587       relocation += symbol->section->output_offset;
2588     }
2589
2590   relocation += reloc_entry->addend;
2591   switch (reloc_entry->howto->type)
2592     {
2593     case R_NDS32_LO12S3:
2594       relocation >>= 3;
2595       break;
2596
2597     case R_NDS32_LO12S2:
2598       relocation >>= 2;
2599       break;
2600
2601     case R_NDS32_LO12S1:
2602       relocation >>= 1;
2603       break;
2604
2605     case R_NDS32_LO12S0:
2606     default:
2607       relocation >>= 0;
2608       break;
2609     }
2610
2611   inplace_address = (bfd_byte *) data + reloc_entry->address;
2612
2613 #define DOIT(x)                                         \
2614   x = ((x & ~reloc_entry->howto->dst_mask) |            \
2615   (((x & reloc_entry->howto->src_mask) +  relocation) & \
2616   reloc_entry->howto->dst_mask))
2617
2618   switch (reloc_entry->howto->size)
2619     {
2620     case 1:
2621       {
2622         short x = bfd_getb16 (inplace_address);
2623
2624         DOIT (x);
2625         bfd_putb16 ((bfd_vma) x, inplace_address);
2626       }
2627       break;
2628     case 2:
2629       {
2630         unsigned long x = bfd_getb32 (inplace_address);
2631
2632         DOIT (x);
2633         bfd_putb32 ((bfd_vma) x, inplace_address);
2634       }
2635       break;
2636     default:
2637       BFD_ASSERT (0);
2638     }
2639
2640   if (output_bfd != (bfd *) NULL)
2641     reloc_entry->address += input_section->output_offset;
2642
2643   return ret;
2644 }
2645
2646 /* Handle the R_NDS32_SDA15 reloc.
2647    This reloc is used to compute the address of objects in the small data area
2648    and to perform loads and stores from that area.
2649    The lower 15 bits are sign extended and added to the register specified
2650    in the instruction, which is assumed to point to _SDA_BASE_.
2651
2652    Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2653    the access size, this must be taken care of.  */
2654
2655 static bfd_reloc_status_type
2656 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2657                        asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2658                        asection *input_section, bfd *output_bfd,
2659                        char **error_message ATTRIBUTE_UNUSED)
2660 {
2661   /* This part is from bfd_elf_generic_reloc.  */
2662   if (output_bfd != (bfd *) NULL
2663       && (symbol->flags & BSF_SECTION_SYM) == 0
2664       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2665     {
2666       reloc_entry->address += input_section->output_offset;
2667       return bfd_reloc_ok;
2668     }
2669
2670   if (output_bfd != NULL)
2671     {
2672       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2673       return bfd_reloc_continue;
2674     }
2675
2676   /* FIXME: not sure what to do here yet.  But then again, the linker
2677      may never call us.  */
2678   abort ();
2679 }
2680
2681 /* nds32_elf_ignore_reloc is the special function for
2682    relocation types which don't need to be relocated
2683    like relaxation relocation types.
2684    This function simply return bfd_reloc_ok when it is
2685    invoked.  */
2686
2687 static bfd_reloc_status_type
2688 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2689                         asymbol *symbol ATTRIBUTE_UNUSED,
2690                         void *data ATTRIBUTE_UNUSED, asection *input_section,
2691                         bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2692 {
2693   if (output_bfd != NULL)
2694     reloc_entry->address += input_section->output_offset;
2695
2696   return bfd_reloc_ok;
2697 }
2698 \f
2699
2700 /* Map BFD reloc types to NDS32 ELF reloc types.  */
2701
2702 struct nds32_reloc_map_entry
2703 {
2704   bfd_reloc_code_real_type bfd_reloc_val;
2705   unsigned char elf_reloc_val;
2706 };
2707
2708 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
2709 {
2710   {BFD_RELOC_NONE, R_NDS32_NONE},
2711   {BFD_RELOC_16, R_NDS32_16_RELA},
2712   {BFD_RELOC_32, R_NDS32_32_RELA},
2713   {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
2714   {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
2715   {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
2716   {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
2717   {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
2718   {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
2719   {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
2720   {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
2721   {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
2722   {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
2723   {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
2724   {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
2725   {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
2726   {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
2727   {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
2728   {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
2729   {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
2730   {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
2731   {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
2732   {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
2733
2734   {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
2735   {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
2736   {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
2737   {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
2738   {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
2739   {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
2740   {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
2741   {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
2742   {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
2743   {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
2744   {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
2745   {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
2746   {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
2747   {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
2748   {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
2749   {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
2750   {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
2751   {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
2752   {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
2753   {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
2754   {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
2755   {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
2756   {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
2757   {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
2758   {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
2759   {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
2760   {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
2761   {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
2762   {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
2763   {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
2764   {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
2765   {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
2766   {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
2767   {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
2768   {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
2769   {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
2770   {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
2771   {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
2772   {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
2773   {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
2774   {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
2775   {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
2776   {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
2777   {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
2778   {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
2779   {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
2780   {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
2781   {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
2782   {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
2783   {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
2784   {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
2785   {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
2786   {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
2787   {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
2788   {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
2789   {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
2790   {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
2791   {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
2792   {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
2793   {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
2794   {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
2795   {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
2796   {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
2797   {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
2798   {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
2799   {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
2800   {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
2801   {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
2802   {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
2803   {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
2804   {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
2805   {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
2806   {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
2807   {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
2808   {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
2809
2810   {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
2811   {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
2812   {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
2813   {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
2814   {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
2815   {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
2816   {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
2817   {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
2818   {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
2819   {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
2820   {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
2821   {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
2822   {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
2823   {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
2824   {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
2825   {BFD_RELOC_NDS32_TLS_TPOFF, R_NDS32_TLS_TPOFF},
2826   {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
2827   {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
2828   {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
2829   {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
2830 };
2831
2832 /* Patch tag.  */
2833
2834 static reloc_howto_type *
2835 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2836                                  const char *r_name)
2837 {
2838   unsigned int i;
2839
2840   for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
2841     if (nds32_elf_howto_table[i].name != NULL
2842         && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
2843       return &nds32_elf_howto_table[i];
2844
2845   for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
2846     if (nds32_elf_relax_howto_table[i].name != NULL
2847         && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
2848       return &nds32_elf_relax_howto_table[i];
2849
2850   return NULL;
2851 }
2852
2853 static reloc_howto_type *
2854 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
2855 {
2856   if (code < R_NDS32_RELAX_ENTRY)
2857     {
2858       BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
2859       return &nds32_elf_howto_table[code];
2860     }
2861   else
2862     {
2863       BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
2864                   < ARRAY_SIZE (nds32_elf_relax_howto_table));
2865       return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
2866     }
2867 }
2868
2869 static reloc_howto_type *
2870 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2871                                  bfd_reloc_code_real_type code)
2872 {
2873   unsigned int i;
2874
2875   for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
2876     {
2877       if (nds32_reloc_map[i].bfd_reloc_val == code)
2878         return bfd_elf32_bfd_reloc_type_table_lookup
2879                  (nds32_reloc_map[i].elf_reloc_val);
2880     }
2881
2882   return NULL;
2883 }
2884
2885 /* Set the howto pointer for an NDS32 ELF reloc.  */
2886
2887 static void
2888 nds32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2889                          Elf_Internal_Rela *dst)
2890 {
2891   enum elf_nds32_reloc_type r_type;
2892
2893   r_type = ELF32_R_TYPE (dst->r_info);
2894   if (r_type > R_NDS32_GNU_VTENTRY)
2895     {
2896       /* xgettext:c-format */
2897       _bfd_error_handler (_("%B: invalid NDS32 reloc number: %d"), abfd, r_type);
2898       r_type = 0;
2899     }
2900   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2901 }
2902
2903 static void
2904 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2905                      Elf_Internal_Rela *dst)
2906 {
2907   BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2908               || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2909                   && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2910   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2911 }
2912
2913 /* Support for core dump NOTE sections.
2914    Reference to include/linux/elfcore.h in Linux.  */
2915
2916 static bfd_boolean
2917 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2918 {
2919   int offset;
2920   size_t size;
2921
2922   switch (note->descsz)
2923     {
2924     case 0x114:
2925       /* Linux/NDS32 32-bit, ABI1 */
2926
2927       /* pr_cursig */
2928       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2929
2930       /* pr_pid */
2931       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
2932
2933       /* pr_reg */
2934       offset = 72;
2935       size = 200;
2936       break;
2937
2938     case 0xfc:
2939       /* Linux/NDS32 32-bit */
2940
2941       /* pr_cursig */
2942       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2943
2944       /* pr_pid */
2945       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
2946
2947       /* pr_reg */
2948       offset = 72;
2949       size = 176;
2950       break;
2951
2952     default:
2953       return FALSE;
2954     }
2955
2956   /* Make a ".reg" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   switch (note->descsz)
2965     {
2966     case 124:
2967       /* Linux/NDS32 */
2968
2969       /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform.  */
2970       elf_tdata (abfd)->core->program =
2971         _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
2972       elf_tdata (abfd)->core->command =
2973         _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
2974       break;
2975
2976     default:
2977       return FALSE;
2978     }
2979
2980   /* Note that for some reason, a spurious space is tacked
2981      onto the end of the args in some (at least one anyway)
2982      implementations, so strip it off if it exists.  */
2983   {
2984     char *command = elf_tdata (abfd)->core->command;
2985     int n = strlen (command);
2986
2987     if (0 < n && command[n - 1] == ' ')
2988       command[n - 1] = '\0';
2989   }
2990
2991   return TRUE;
2992 }
2993
2994 /* Hook called by the linker routine which adds symbols from an object
2995    file.  We must handle the special NDS32 section numbers here.
2996    We also keep watching for whether we need to create the sdata special
2997    linker sections.  */
2998
2999 static bfd_boolean
3000 nds32_elf_add_symbol_hook (bfd *abfd,
3001                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3002                            Elf_Internal_Sym *sym,
3003                            const char **namep ATTRIBUTE_UNUSED,
3004                            flagword *flagsp ATTRIBUTE_UNUSED,
3005                            asection **secp, bfd_vma *valp)
3006 {
3007   switch (sym->st_shndx)
3008     {
3009     case SHN_COMMON:
3010       /* Common symbols less than the GP size are automatically
3011          treated as SHN_MIPS_SCOMMON symbols.  */
3012       if (sym->st_size > elf_gp_size (abfd)
3013           || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3014         break;
3015
3016       /* st_value is the alignemnt constraint.
3017          That might be its actual size if it is an array or structure.  */
3018       switch (sym->st_value)
3019         {
3020         case 1:
3021           *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3022           break;
3023         case 2:
3024           *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3025           break;
3026         case 4:
3027           *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3028           break;
3029         case 8:
3030           *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3031           break;
3032         default:
3033           return TRUE;
3034         }
3035
3036       (*secp)->flags |= SEC_IS_COMMON;
3037       *valp = sym->st_size;
3038       break;
3039     }
3040
3041   return TRUE;
3042 }
3043
3044
3045 /* This function can figure out the best location for a base register to access
3046    data relative to this base register
3047    INPUT:
3048    sda_d0: size of first DOUBLE WORD data section
3049    sda_w0: size of first WORD data section
3050    sda_h0: size of first HALF WORD data section
3051    sda_b : size of BYTE data section
3052    sda_hi: size of second HALF WORD data section
3053    sda_w1: size of second WORD data section
3054    sda_d1: size of second DOUBLE WORD data section
3055    OUTPUT:
3056    offset (always positive) from the beginning of sda_d0 if OK
3057    a negative error value if fail
3058    NOTE:
3059    these 7 sections have to be located back to back if exist
3060    a pass in 0 value for non-existing section   */
3061
3062 /* Due to the interpretation of simm15 field of load/store depending on
3063    data accessing size, the organization of base register relative data shall
3064    like the following figure
3065    -------------------------------------------
3066    |  DOUBLE WORD sized data (range +/- 128K)
3067    -------------------------------------------
3068    |  WORD sized data (range +/- 64K)
3069    -------------------------------------------
3070    |  HALF WORD sized data (range +/- 32K)
3071    -------------------------------------------
3072    |  BYTE sized data (range +/- 16K)
3073    -------------------------------------------
3074    |  HALF WORD sized data (range +/- 32K)
3075    -------------------------------------------
3076    |  WORD sized data (range +/- 64K)
3077    -------------------------------------------
3078    |  DOUBLE WORD sized data (range +/- 128K)
3079    -------------------------------------------
3080    Its base register shall be set to access these data freely.  */
3081
3082 /* We have to figure out the SDA_BASE value, so that we can adjust the
3083    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
3084    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
3085    target data.  We don't need to adjust the symbol value for an
3086    external symbol if we are producing relocatable output.  */
3087
3088 static asection *sda_rela_sec = NULL;
3089
3090 #define SDA_SECTION_NUM 10
3091
3092 static bfd_reloc_status_type
3093 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3094                           bfd_vma *psb, bfd_boolean add_symbol)
3095 {
3096   int relax_fp_as_gp;
3097   struct elf_nds32_link_hash_table *table;
3098   struct bfd_link_hash_entry *h, *h2;
3099   long unsigned int total = 0;
3100
3101   h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3102   if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3103     {
3104       asection *first = NULL, *final = NULL, *temp;
3105       bfd_vma sda_base;
3106       /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3107          4 byte-aligned.  Therefore, it has to set the first section ".data"
3108          4 byte-aligned.  */
3109       static const char sec_name[SDA_SECTION_NUM][10] =
3110         {
3111           ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3112           ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3113         };
3114       size_t i = 0;
3115
3116       if (output_bfd->sections == NULL)
3117         {
3118           *psb = elf_gp (output_bfd);
3119           return bfd_reloc_ok;
3120         }
3121
3122       /* Get the first and final section.  */
3123       while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3124         {
3125           temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3126           if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3127             first = temp;
3128           if (temp && (temp->size != 0 || temp->rawsize != 0))
3129             final = temp;
3130
3131           /* Summarize the sections in order to check if joining .bss.  */
3132           if (temp && temp->size != 0)
3133             total += temp->size;
3134           else if (temp && temp->rawsize != 0)
3135             total += temp->rawsize;
3136
3137           i++;
3138         }
3139
3140       /* Check .bss size.  */
3141       temp = bfd_get_section_by_name (output_bfd, ".bss");
3142       if (temp)
3143         {
3144           if (temp->size != 0)
3145             total += temp->size;
3146           else if (temp->rawsize != 0)
3147             total += temp->rawsize;
3148
3149           if (total < 0x80000)
3150             {
3151               if (!first && (temp->size != 0 || temp->rawsize != 0))
3152                 first = temp;
3153               if ((temp->size != 0 || temp->rawsize != 0))
3154                 final = temp;
3155             }
3156         }
3157
3158       if (first && final)
3159         {
3160           /* The middle of data region.  */
3161           sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3162
3163           /* Find the section sda_base located.  */
3164           i = 0;
3165           while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3166             {
3167               final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3168               if (final && (final->size != 0 || final->rawsize != 0)
3169                   && sda_base >= final->vma)
3170                 {
3171                   first = final;
3172                   i++;
3173                 }
3174               else
3175                 break;
3176             }
3177         }
3178       else
3179         {
3180           /* There is not any data section in output bfd, and set _SDA_BASE_ in
3181              first output section.  */
3182           first = output_bfd->sections;
3183           while (first && first->size == 0 && first->rawsize == 0)
3184             first = first->next;
3185           if (!first)
3186             {
3187               *psb = elf_gp (output_bfd);
3188               return bfd_reloc_ok;
3189             }
3190           sda_base = first->vma + first->rawsize;
3191         }
3192
3193       sda_base -= first->vma;
3194       sda_base = sda_base & (~7);
3195
3196       if (!_bfd_generic_link_add_one_symbol
3197              (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3198               (bfd_vma) sda_base, (const char *) NULL, FALSE,
3199               get_elf_backend_data (output_bfd)->collect, &h))
3200         return FALSE;
3201
3202       sda_rela_sec = first;
3203
3204       table = nds32_elf_hash_table (info);
3205       relax_fp_as_gp = table->relax_fp_as_gp;
3206       if (relax_fp_as_gp)
3207         {
3208           h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3209                                      FALSE, FALSE, FALSE);
3210           /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3211              And set FP equal to SDA_BASE to do relaxation for
3212              la $fp, _FP_BASE_.  */
3213           if (!_bfd_generic_link_add_one_symbol
3214                  (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3215                   first, (bfd_vma) sda_base, (const char *) NULL,
3216                   FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3217             return FALSE;
3218         }
3219     }
3220
3221   if (add_symbol)
3222     {
3223       if (h)
3224         {
3225           /* Now set gp.  */
3226           elf_gp (output_bfd) = (h->u.def.value
3227                                  + h->u.def.section->output_section->vma
3228                                  + h->u.def.section->output_offset);
3229         }
3230       else
3231         {
3232           _bfd_error_handler (_("error: Can't find symbol: _SDA_BASE_."));
3233           return bfd_reloc_dangerous;
3234         }
3235     }
3236
3237   *psb = h->u.def.value + h->u.def.section->output_section->vma
3238          + h->u.def.section->output_offset;
3239   return bfd_reloc_ok;
3240 }
3241 \f
3242
3243 /* Return size of a PLT entry.  */
3244 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3245
3246
3247 /* Create an entry in an nds32 ELF linker hash table.  */
3248
3249 static struct bfd_hash_entry *
3250 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3251                              struct bfd_hash_table *table,
3252                              const char *string)
3253 {
3254   struct elf_nds32_link_hash_entry *ret;
3255
3256   ret = (struct elf_nds32_link_hash_entry *) entry;
3257
3258   /* Allocate the structure if it has not already been allocated by a
3259      subclass.  */
3260   if (ret == NULL)
3261     ret = (struct elf_nds32_link_hash_entry *)
3262        bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3263
3264   if (ret == NULL)
3265     return (struct bfd_hash_entry *) ret;
3266
3267   /* Call the allocation method of the superclass.  */
3268   ret = (struct elf_nds32_link_hash_entry *)
3269     _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3270
3271   if (ret != NULL)
3272     {
3273       struct elf_nds32_link_hash_entry *eh;
3274
3275       eh = (struct elf_nds32_link_hash_entry *) ret;
3276       eh->dyn_relocs = NULL;
3277       eh->tls_type = GOT_UNKNOWN;
3278     }
3279
3280   return (struct bfd_hash_entry *) ret;
3281 }
3282
3283 /* Create an nds32 ELF linker hash table.  */
3284
3285 static struct bfd_link_hash_table *
3286 nds32_elf_link_hash_table_create (bfd *abfd)
3287 {
3288   struct elf_nds32_link_hash_table *ret;
3289
3290   bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3291
3292   ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3293   if (ret == NULL)
3294     return NULL;
3295
3296   /* patch tag.  */
3297   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3298                                       nds32_elf_link_hash_newfunc,
3299                                       sizeof (struct elf_nds32_link_hash_entry),
3300                                       NDS32_ELF_DATA))
3301     {
3302       free (ret);
3303       return NULL;
3304     }
3305
3306   return &ret->root.root;
3307 }
3308
3309 /* Create dynamic sections when linking against a dynamic object.  */
3310
3311 static bfd_boolean
3312 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3313 {
3314   struct elf_nds32_link_hash_table *htab;
3315   flagword flags, pltflags;
3316   register asection *s;
3317   const struct elf_backend_data *bed;
3318   int ptralign = 2;             /* 32-bit  */
3319
3320   bed = get_elf_backend_data (abfd);
3321
3322   htab = nds32_elf_hash_table (info);
3323
3324   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3325      .rel[a].bss sections.  */
3326
3327   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3328            | SEC_LINKER_CREATED);
3329
3330   pltflags = flags;
3331   pltflags |= SEC_CODE;
3332   if (bed->plt_not_loaded)
3333     pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3334   if (bed->plt_readonly)
3335     pltflags |= SEC_READONLY;
3336
3337   s = bfd_make_section (abfd, ".plt");
3338   htab->root.splt = s;
3339   if (s == NULL
3340       || !bfd_set_section_flags (abfd, s, pltflags)
3341       || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3342     return FALSE;
3343
3344   if (bed->want_plt_sym)
3345     {
3346       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3347          .plt section.  */
3348       struct bfd_link_hash_entry *bh = NULL;
3349       struct elf_link_hash_entry *h;
3350
3351       if (!(_bfd_generic_link_add_one_symbol
3352             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3353              (bfd_vma) 0, (const char *) NULL, FALSE,
3354              get_elf_backend_data (abfd)->collect, &bh)))
3355         return FALSE;
3356
3357       h = (struct elf_link_hash_entry *) bh;
3358       h->def_regular = 1;
3359       h->type = STT_OBJECT;
3360
3361       if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3362         return FALSE;
3363     }
3364
3365   s = bfd_make_section (abfd,
3366                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3367   htab->root.srelplt = s;
3368   if (s == NULL
3369       || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3370       || !bfd_set_section_alignment (abfd, s, ptralign))
3371     return FALSE;
3372
3373   if (htab->root.sgot == NULL && !_bfd_elf_create_got_section (abfd, info))
3374     return FALSE;
3375
3376   {
3377     const char *secname;
3378     char *relname;
3379     flagword secflags;
3380     asection *sec;
3381
3382     for (sec = abfd->sections; sec; sec = sec->next)
3383       {
3384         secflags = bfd_get_section_flags (abfd, sec);
3385         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3386             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3387           continue;
3388         secname = bfd_get_section_name (abfd, sec);
3389         relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3390         strcpy (relname, ".rela");
3391         strcat (relname, secname);
3392         if (bfd_get_section_by_name (abfd, secname))
3393           continue;
3394         s = bfd_make_section (abfd, relname);
3395         if (s == NULL
3396             || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3397             || !bfd_set_section_alignment (abfd, s, ptralign))
3398           return FALSE;
3399       }
3400   }
3401
3402   if (bed->want_dynbss)
3403     {
3404       /* The .dynbss section is a place to put symbols which are defined
3405          by dynamic objects, are referenced by regular objects, and are
3406          not functions.  We must allocate space for them in the process
3407          image and use a R_*_COPY reloc to tell the dynamic linker to
3408          initialize them at run time.  The linker script puts the .dynbss
3409          section into the .bss section of the final image.  */
3410       s = bfd_make_section (abfd, ".dynbss");
3411       htab->sdynbss = s;
3412       if (s == NULL
3413           || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3414         return FALSE;
3415       /* The .rel[a].bss section holds copy relocs.  This section is not
3416          normally needed.  We need to create it here, though, so that the
3417          linker will map it to an output section.  We can't just create it
3418          only if we need it, because we will not know whether we need it
3419          until we have seen all the input files, and the first time the
3420          main linker code calls BFD after examining all the input files
3421          (size_dynamic_sections) the input sections have already been
3422          mapped to the output sections.  If the section turns out not to
3423          be needed, we can discard it later.  We will never need this
3424          section when generating a shared object, since they do not use
3425          copy relocs.  */
3426       if (!bfd_link_pic (info))
3427         {
3428           s = bfd_make_section (abfd, (bed->default_use_rela_p
3429                                        ? ".rela.bss" : ".rel.bss"));
3430           htab->srelbss = s;
3431           if (s == NULL
3432               || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3433               || !bfd_set_section_alignment (abfd, s, ptralign))
3434             return FALSE;
3435         }
3436     }
3437
3438   return TRUE;
3439 }
3440
3441 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3442 static void
3443 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3444                                 struct elf_link_hash_entry *dir,
3445                                 struct elf_link_hash_entry *ind)
3446 {
3447   struct elf_nds32_link_hash_entry *edir, *eind;
3448
3449   edir = (struct elf_nds32_link_hash_entry *) dir;
3450   eind = (struct elf_nds32_link_hash_entry *) ind;
3451
3452   if (eind->dyn_relocs != NULL)
3453     {
3454       if (edir->dyn_relocs != NULL)
3455         {
3456           struct elf_dyn_relocs **pp;
3457           struct elf_dyn_relocs *p;
3458
3459           if (ind->root.type == bfd_link_hash_indirect)
3460             abort ();
3461
3462           /* Add reloc counts against the weak sym to the strong sym
3463              list.  Merge any entries against the same section.  */
3464           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3465             {
3466               struct elf_dyn_relocs *q;
3467
3468               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3469                 if (q->sec == p->sec)
3470                   {
3471                     q->pc_count += p->pc_count;
3472                     q->count += p->count;
3473                     *pp = p->next;
3474                     break;
3475                   }
3476               if (q == NULL)
3477                 pp = &p->next;
3478             }
3479           *pp = edir->dyn_relocs;
3480         }
3481
3482       edir->dyn_relocs = eind->dyn_relocs;
3483       eind->dyn_relocs = NULL;
3484     }
3485
3486   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3487 }
3488 \f
3489 /* Find dynamic relocs for H that apply to read-only sections.  */
3490
3491 static asection *
3492 readonly_dynrelocs (struct elf_link_hash_entry *h)
3493 {
3494   struct elf_dyn_relocs *p;
3495
3496   for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3497     {
3498       asection *s = p->sec->output_section;
3499
3500       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3501         return p->sec;
3502     }
3503   return NULL;
3504 }
3505
3506 /* Adjust a symbol defined by a dynamic object and referenced by a
3507    regular object.  The current definition is in some section of the
3508    dynamic object, but we're not including those sections.  We have to
3509    change the definition to something the rest of the link can
3510    understand.  */
3511
3512 static bfd_boolean
3513 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3514                                  struct elf_link_hash_entry *h)
3515 {
3516   struct elf_nds32_link_hash_table *htab;
3517   bfd *dynobj;
3518   asection *s;
3519   unsigned int power_of_two;
3520
3521   dynobj = elf_hash_table (info)->dynobj;
3522
3523   /* Make sure we know what is going on here.  */
3524   BFD_ASSERT (dynobj != NULL
3525               && (h->needs_plt
3526                   || h->is_weakalias
3527                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3528
3529
3530   /* If this is a function, put it in the procedure linkage table.  We
3531      will fill in the contents of the procedure linkage table later,
3532      when we know the address of the .got section.  */
3533   if (h->type == STT_FUNC || h->needs_plt)
3534     {
3535       if (!bfd_link_pic (info)
3536           && !h->def_dynamic
3537           && !h->ref_dynamic
3538           && h->root.type != bfd_link_hash_undefweak
3539           && h->root.type != bfd_link_hash_undefined)
3540         {
3541           /* This case can occur if we saw a PLT reloc in an input
3542              file, but the symbol was never referred to by a dynamic
3543              object.  In such a case, we don't actually need to build
3544              a procedure linkage table, and we can just do a PCREL
3545              reloc instead.  */
3546           h->plt.offset = (bfd_vma) - 1;
3547           h->needs_plt = 0;
3548         }
3549
3550       return TRUE;
3551     }
3552   else
3553     h->plt.offset = (bfd_vma) - 1;
3554
3555   /* If this is a weak symbol, and there is a real definition, the
3556      processor independent code will have arranged for us to see the
3557      real definition first, and we can just use the same value.  */
3558   if (h->is_weakalias)
3559     {
3560       struct elf_link_hash_entry *def = weakdef (h);
3561       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3562       h->root.u.def.section = def->root.u.def.section;
3563       h->root.u.def.value = def->root.u.def.value;
3564       return TRUE;
3565     }
3566
3567   /* This is a reference to a symbol defined by a dynamic object which
3568      is not a function.  */
3569
3570   /* If we are creating a shared library, we must presume that the
3571      only references to the symbol are via the global offset table.
3572      For such cases we need not do anything here; the relocations will
3573      be handled correctly by relocate_section.  */
3574   if (bfd_link_pic (info))
3575     return TRUE;
3576
3577   /* If there are no references to this symbol that do not use the
3578      GOT, we don't need to generate a copy reloc.  */
3579   if (!h->non_got_ref)
3580     return TRUE;
3581
3582   /* If -z nocopyreloc was given, we won't generate them either.  */
3583   if (0 && info->nocopyreloc)
3584     {
3585       h->non_got_ref = 0;
3586       return TRUE;
3587     }
3588
3589   /* If we don't find any dynamic relocs in read-only sections, then
3590      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
3591   if (0 && !readonly_dynrelocs (h))
3592     {
3593       h->non_got_ref = 0;
3594       return TRUE;
3595     }
3596
3597   /* We must allocate the symbol in our .dynbss section, which will
3598      become part of the .bss section of the executable.  There will be
3599      an entry for this symbol in the .dynsym section.  The dynamic
3600      object will contain position independent code, so all references
3601      from the dynamic object to this symbol will go through the global
3602      offset table.  The dynamic linker will use the .dynsym entry to
3603      determine the address it must put in the global offset table, so
3604      both the dynamic object and the regular object will refer to the
3605      same memory location for the variable.  */
3606
3607   htab = nds32_elf_hash_table (info);
3608   s = htab->sdynbss;
3609   BFD_ASSERT (s != NULL);
3610
3611   /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3612      to copy the initial value out of the dynamic object and into the
3613      runtime process image.  We need to remember the offset into the
3614      .rela.bss section we are going to use.  */
3615   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3616     {
3617       asection *srel;
3618
3619       srel = htab->srelbss;
3620       BFD_ASSERT (srel != NULL);
3621       srel->size += sizeof (Elf32_External_Rela);
3622       h->needs_copy = 1;
3623     }
3624
3625   /* We need to figure out the alignment required for this symbol.  I
3626      have no idea how ELF linkers handle this.  */
3627   power_of_two = bfd_log2 (h->size);
3628   if (power_of_two > 3)
3629     power_of_two = 3;
3630
3631   /* Apply the required alignment.  */
3632   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3633   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3634     {
3635       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3636         return FALSE;
3637     }
3638
3639   /* Define the symbol as being at this point in the section.  */
3640   h->root.u.def.section = s;
3641   h->root.u.def.value = s->size;
3642
3643   /* Increment the section size to make room for the symbol.  */
3644   s->size += h->size;
3645
3646   return TRUE;
3647 }
3648
3649 /* Allocate space in .plt, .got and associated reloc sections for
3650    dynamic relocs.  */
3651
3652 static bfd_boolean
3653 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3654 {
3655   struct bfd_link_info *info;
3656   struct elf_nds32_link_hash_table *htab;
3657   struct elf_nds32_link_hash_entry *eh;
3658   struct elf_dyn_relocs *p;
3659
3660   if (h->root.type == bfd_link_hash_indirect)
3661     return TRUE;
3662
3663   if (h->root.type == bfd_link_hash_warning)
3664     /* When warning symbols are created, they **replace** the "real"
3665        entry in the hash table, thus we never get to see the real
3666        symbol in a hash traversal.  So look at it now.  */
3667     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3668
3669   info = (struct bfd_link_info *) inf;
3670   htab = nds32_elf_hash_table (info);
3671
3672   eh = (struct elf_nds32_link_hash_entry *) h;
3673
3674   if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3675     {
3676       /* Make sure this symbol is output as a dynamic symbol.
3677          Undefined weak syms won't yet be marked as dynamic.  */
3678       if (h->dynindx == -1 && !h->forced_local)
3679         {
3680           if (!bfd_elf_link_record_dynamic_symbol (info, h))
3681             return FALSE;
3682         }
3683
3684       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
3685         {
3686           asection *s = htab->root.splt;
3687
3688           /* If this is the first .plt entry, make room for the special
3689              first entry.  */
3690           if (s->size == 0)
3691             s->size += PLT_ENTRY_SIZE;
3692
3693           h->plt.offset = s->size;
3694
3695           /* If this symbol is not defined in a regular file, and we are
3696              not generating a shared library, then set the symbol to this
3697              location in the .plt.  This is required to make function
3698              pointers compare as equal between the normal executable and
3699              the shared library.  */
3700           if (!bfd_link_pic (info) && !h->def_regular)
3701             {
3702               h->root.u.def.section = s;
3703               h->root.u.def.value = h->plt.offset;
3704             }
3705
3706           /* Make room for this entry.  */
3707           s->size += PLT_ENTRY_SIZE;
3708
3709           /* We also need to make an entry in the .got.plt section, which
3710              will be placed in the .got section by the linker script.  */
3711           htab->root.sgotplt->size += 4;
3712
3713           /* We also need to make an entry in the .rel.plt section.  */
3714           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
3715         }
3716       else
3717         {
3718           h->plt.offset = (bfd_vma) - 1;
3719           h->needs_plt = 0;
3720         }
3721     }
3722   else
3723     {
3724       h->plt.offset = (bfd_vma) - 1;
3725       h->needs_plt = 0;
3726     }
3727
3728   if (h->got.refcount > 0)
3729     {
3730       asection *s;
3731       bfd_boolean dyn;
3732       int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3733
3734       /* Make sure this symbol is output as a dynamic symbol.
3735          Undefined weak syms won't yet be marked as dynamic.  */
3736       if (h->dynindx == -1 && !h->forced_local)
3737         {
3738           if (!bfd_elf_link_record_dynamic_symbol (info, h))
3739             return FALSE;
3740         }
3741
3742       s = htab->root.sgot;
3743       h->got.offset = s->size;
3744
3745       if (tls_type == GOT_UNKNOWN)
3746         abort ();
3747       else if (tls_type == GOT_NORMAL
3748                || tls_type == GOT_TLS_IE)
3749         /* Need a GOT slot.  */
3750         s->size += 4;
3751
3752       dyn = htab->root.dynamic_sections_created;
3753       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
3754         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3755     }
3756   else
3757     h->got.offset = (bfd_vma) - 1;
3758
3759   if (eh->dyn_relocs == NULL)
3760     return TRUE;
3761
3762   /* In the shared -Bsymbolic case, discard space allocated for
3763      dynamic pc-relative relocs against symbols which turn out to be
3764      defined in regular objects.  For the normal shared case, discard
3765      space for pc-relative relocs that have become local due to symbol
3766      visibility changes.  */
3767
3768   if (bfd_link_pic (info))
3769     {
3770       if (h->def_regular && (h->forced_local || info->symbolic))
3771         {
3772           struct elf_dyn_relocs **pp;
3773
3774           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3775             {
3776               p->count -= p->pc_count;
3777               p->pc_count = 0;
3778               if (p->count == 0)
3779                 *pp = p->next;
3780               else
3781                 pp = &p->next;
3782             }
3783         }
3784     }
3785   else
3786     {
3787       /* For the non-shared case, discard space for relocs against
3788          symbols which turn out to need copy relocs or are not dynamic.  */
3789
3790       if (!h->non_got_ref
3791           && ((h->def_dynamic
3792                && !h->def_regular)
3793               || (htab->root.dynamic_sections_created
3794                   && (h->root.type == bfd_link_hash_undefweak
3795                       || h->root.type == bfd_link_hash_undefined))))
3796         {
3797           /* Make sure this symbol is output as a dynamic symbol.
3798              Undefined weak syms won't yet be marked as dynamic.  */
3799           if (h->dynindx == -1 && !h->forced_local)
3800             {
3801               if (!bfd_elf_link_record_dynamic_symbol (info, h))
3802                 return FALSE;
3803             }
3804
3805           /* If that succeeded, we know we'll be keeping all the
3806              relocs.  */
3807           if (h->dynindx != -1)
3808             goto keep;
3809         }
3810
3811       eh->dyn_relocs = NULL;
3812
3813     keep:;
3814     }
3815
3816   /* Finally, allocate space.  */
3817   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3818     {
3819       asection *sreloc = elf_section_data (p->sec)->sreloc;
3820       sreloc->size += p->count * sizeof (Elf32_External_Rela);
3821     }
3822
3823   return TRUE;
3824 }
3825
3826 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
3827    read-only sections.  */
3828
3829 static bfd_boolean
3830 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
3831 {
3832   asection *sec;
3833
3834   if (h->root.type == bfd_link_hash_indirect)
3835     return TRUE;
3836
3837   sec = readonly_dynrelocs (h);
3838   if (sec != NULL)
3839     {
3840       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
3841
3842       info->flags |= DF_TEXTREL;
3843       info->callbacks->minfo
3844         (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
3845          sec->owner, h->root.root.string, sec);
3846
3847       /* Not an error, just cut short the traversal.  */
3848       return FALSE;
3849     }
3850   return TRUE;
3851 }
3852
3853 /* Set the sizes of the dynamic sections.  */
3854
3855 static bfd_boolean
3856 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3857                                  struct bfd_link_info *info)
3858 {
3859   struct elf_nds32_link_hash_table *htab;
3860   bfd *dynobj;
3861   asection *s;
3862   bfd_boolean relocs;
3863   bfd *ibfd;
3864
3865   htab = nds32_elf_hash_table (info);
3866   dynobj = htab->root.dynobj;
3867   BFD_ASSERT (dynobj != NULL);
3868
3869   if (htab->root.dynamic_sections_created)
3870     {
3871       /* Set the contents of the .interp section to the interpreter.  */
3872       if (bfd_link_executable (info) && !info->nointerp)
3873         {
3874           s = bfd_get_section_by_name (dynobj, ".interp");
3875           BFD_ASSERT (s != NULL);
3876           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3877           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3878         }
3879     }
3880
3881   /* Set up .got offsets for local syms, and space for local dynamic
3882      relocs.  */
3883   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3884     {
3885       bfd_signed_vma *local_got;
3886       bfd_signed_vma *end_local_got;
3887       bfd_size_type locsymcount;
3888       Elf_Internal_Shdr *symtab_hdr;
3889       asection *srel;
3890
3891       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3892         continue;
3893
3894       for (s = ibfd->sections; s != NULL; s = s->next)
3895         {
3896           struct elf_dyn_relocs *p;
3897
3898           for (p = ((struct elf_dyn_relocs *)
3899                     elf_section_data (s)->local_dynrel);
3900                p != NULL; p = p->next)
3901             {
3902               if (!bfd_is_abs_section (p->sec)
3903                   && bfd_is_abs_section (p->sec->output_section))
3904                 {
3905                   /* Input section has been discarded, either because
3906                      it is a copy of a linkonce section or due to
3907                      linker script /DISCARD/, so we'll be discarding
3908                      the relocs too.  */
3909                 }
3910               else if (p->count != 0)
3911                 {
3912                   srel = elf_section_data (p->sec)->sreloc;
3913                   srel->size += p->count * sizeof (Elf32_External_Rela);
3914                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3915                     info->flags |= DF_TEXTREL;
3916                 }
3917             }
3918         }
3919
3920       local_got = elf_local_got_refcounts (ibfd);
3921       if (!local_got)
3922         continue;
3923
3924       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3925       locsymcount = symtab_hdr->sh_info;
3926       end_local_got = local_got + locsymcount;
3927       s = htab->root.sgot;
3928       srel = htab->root.srelgot;
3929       for (; local_got < end_local_got; ++local_got)
3930         {
3931           if (*local_got > 0)
3932             {
3933               *local_got = s->size;
3934               s->size += 4;
3935               if (bfd_link_pic (info))
3936                 srel->size += sizeof (Elf32_External_Rela);
3937             }
3938           else
3939             *local_got = (bfd_vma) - 1;
3940         }
3941     }
3942
3943   /* Allocate global sym .plt and .got entries, and space for global
3944      sym dynamic relocs.  */
3945   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
3946
3947   /* We now have determined the sizes of the various dynamic sections.
3948      Allocate memory for them.  */
3949   relocs = FALSE;
3950   for (s = dynobj->sections; s != NULL; s = s->next)
3951     {
3952       if ((s->flags & SEC_LINKER_CREATED) == 0)
3953         continue;
3954
3955       if (s == htab->root.splt)
3956         {
3957           /* Strip this section if we don't need it; see the
3958              comment below.  */
3959         }
3960       else if (s == htab->root.sgot)
3961         {
3962           got_size += s->size;
3963         }
3964       else if (s == htab->root.sgotplt)
3965         {
3966           got_size += s->size;
3967         }
3968       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
3969         {
3970           if (s->size != 0 && s != htab->root.srelplt)
3971             relocs = TRUE;
3972
3973           /* We use the reloc_count field as a counter if we need
3974              to copy relocs into the output file.  */
3975           s->reloc_count = 0;
3976         }
3977       else
3978         {
3979           /* It's not one of our sections, so don't allocate space.  */
3980           continue;
3981         }
3982
3983       if (s->size == 0)
3984         {
3985           /* If we don't need this section, strip it from the
3986              output file.  This is mostly to handle .rela.bss and
3987              .rela.plt.  We must create both sections in
3988              create_dynamic_sections, because they must be created
3989              before the linker maps input sections to output
3990              sections.  The linker does that before
3991              adjust_dynamic_symbol is called, and it is that
3992              function which decides whether anything needs to go
3993              into these sections.  */
3994           s->flags |= SEC_EXCLUDE;
3995           continue;
3996         }
3997
3998       /* Allocate memory for the section contents.  We use bfd_zalloc
3999          here in case unused entries are not reclaimed before the
4000          section's contents are written out.  This should not happen,
4001          but this way if it does, we get a R_NDS32_NONE reloc instead
4002          of garbage.  */
4003       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4004       if (s->contents == NULL)
4005         return FALSE;
4006     }
4007
4008
4009   if (htab->root.dynamic_sections_created)
4010     {
4011       /* Add some entries to the .dynamic section.  We fill in the
4012          values later, in nds32_elf_finish_dynamic_sections, but we
4013          must add the entries now so that we get the correct size for
4014          the .dynamic section.  The DT_DEBUG entry is filled in by the
4015          dynamic linker and used by the debugger.  */
4016 #define add_dynamic_entry(TAG, VAL) \
4017   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4018
4019       if (!bfd_link_pic (info))
4020         {
4021           if (!add_dynamic_entry (DT_DEBUG, 0))
4022             return FALSE;
4023         }
4024
4025       if (htab->root.splt->size != 0)
4026         {
4027           if (!add_dynamic_entry (DT_PLTGOT, 0)
4028               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4029               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4030               || !add_dynamic_entry (DT_JMPREL, 0))
4031             return FALSE;
4032         }
4033
4034       if (relocs)
4035         {
4036           if (!add_dynamic_entry (DT_RELA, 0)
4037               || !add_dynamic_entry (DT_RELASZ, 0)
4038               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4039             return FALSE;
4040
4041           /* If any dynamic relocs apply to a read-only section,
4042              then we need a DT_TEXTREL entry.  */
4043           if ((info->flags & DF_TEXTREL) == 0)
4044             elf_link_hash_traverse (&htab->root, maybe_set_textrel,
4045                                     (void *) info);
4046
4047           if ((info->flags & DF_TEXTREL) != 0)
4048             {
4049               if (!add_dynamic_entry (DT_TEXTREL, 0))
4050                 return FALSE;
4051             }
4052         }
4053     }
4054 #undef add_dynamic_entry
4055
4056   return TRUE;
4057 }
4058
4059 static bfd_reloc_status_type
4060 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4061                          bfd_vma relocation, bfd_byte *location)
4062 {
4063   int size;
4064   bfd_vma x = 0;
4065   bfd_reloc_status_type flag;
4066   unsigned int rightshift = howto->rightshift;
4067   unsigned int bitpos = howto->bitpos;
4068
4069   /* If the size is negative, negate RELOCATION.  This isn't very
4070      general.  */
4071   if (howto->size < 0)
4072     relocation = -relocation;
4073
4074   /* Get the value we are going to relocate.  */
4075   size = bfd_get_reloc_size (howto);
4076   switch (size)
4077     {
4078     default:
4079       abort ();
4080       break;
4081     case 0:
4082       return bfd_reloc_ok;
4083     case 2:
4084       x = bfd_getb16 (location);
4085       break;
4086     case 4:
4087       x = bfd_getb32 (location);
4088       break;
4089     }
4090
4091   /* Check for overflow.  FIXME: We may drop bits during the addition
4092      which we don't check for.  We must either check at every single
4093      operation, which would be tedious, or we must do the computations
4094      in a type larger than bfd_vma, which would be inefficient.  */
4095   flag = bfd_reloc_ok;
4096   if (howto->complain_on_overflow != complain_overflow_dont)
4097     {
4098       bfd_vma addrmask, fieldmask, signmask, ss;
4099       bfd_vma a, b, sum;
4100
4101       /* Get the values to be added together.  For signed and unsigned
4102          relocations, we assume that all values should be truncated to
4103          the size of an address.  For bitfields, all the bits matter.
4104          See also bfd_check_overflow.  */
4105       fieldmask = N_ONES (howto->bitsize);
4106       signmask = ~fieldmask;
4107       addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4108       a = (relocation & addrmask) >> rightshift;
4109       b = (x & howto->src_mask & addrmask) >> bitpos;
4110
4111       switch (howto->complain_on_overflow)
4112         {
4113         case complain_overflow_signed:
4114           /* If any sign bits are set, all sign bits must be set.
4115              That is, A must be a valid negative address after
4116              shifting.  */
4117           signmask = ~(fieldmask >> 1);
4118           /* Fall through.  */
4119
4120         case complain_overflow_bitfield:
4121           /* Much like the signed check, but for a field one bit
4122              wider.  We allow a bitfield to represent numbers in the
4123              range -2**n to 2**n-1, where n is the number of bits in the
4124              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
4125              can't overflow, which is exactly what we want.  */
4126           ss = a & signmask;
4127           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4128             flag = bfd_reloc_overflow;
4129
4130           /* We only need this next bit of code if the sign bit of B
4131              is below the sign bit of A.  This would only happen if
4132              SRC_MASK had fewer bits than BITSIZE.  Note that if
4133              SRC_MASK has more bits than BITSIZE, we can get into
4134              trouble; we would need to verify that B is in range, as
4135              we do for A above.  */
4136           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4137           ss >>= bitpos;
4138
4139           /* Set all the bits above the sign bit.  */
4140           b = (b ^ ss) - ss;
4141
4142           /* Now we can do the addition.  */
4143           sum = a + b;
4144
4145           /* See if the result has the correct sign.  Bits above the
4146              sign bit are junk now; ignore them.  If the sum is
4147              positive, make sure we did not have all negative inputs;
4148              if the sum is negative, make sure we did not have all
4149              positive inputs.  The test below looks only at the sign
4150              bits, and it really just
4151              SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4152
4153              We mask with addrmask here to explicitly allow an address
4154              wrap-around.  The Linux kernel relies on it, and it is
4155              the only way to write assembler code which can run when
4156              loaded at a location 0x80000000 away from the location at
4157              which it is linked.  */
4158           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4159             flag = bfd_reloc_overflow;
4160
4161           break;
4162
4163         case complain_overflow_unsigned:
4164           /* Checking for an unsigned overflow is relatively easy:
4165              trim the addresses and add, and trim the result as well.
4166              Overflow is normally indicated when the result does not
4167              fit in the field.  However, we also need to consider the
4168              case when, e.g., fieldmask is 0x7fffffff or smaller, an
4169              input is 0x80000000, and bfd_vma is only 32 bits; then we
4170              will get sum == 0, but there is an overflow, since the
4171              inputs did not fit in the field.  Instead of doing a
4172              separate test, we can check for this by or-ing in the
4173              operands when testing for the sum overflowing its final
4174              field.  */
4175           sum = (a + b) & addrmask;
4176           if ((a | b | sum) & signmask)
4177             flag = bfd_reloc_overflow;
4178           break;
4179
4180         default:
4181           abort ();
4182         }
4183     }
4184
4185   /* Put RELOCATION in the right bits.  */
4186   relocation >>= (bfd_vma) rightshift;
4187   relocation <<= (bfd_vma) bitpos;
4188
4189   /* Add RELOCATION to the right bits of X.  */
4190   /* FIXME : 090616
4191      Because the relaxation may generate duplicate relocation at one address,
4192      an addition to immediate in the instruction may cause the relocation added
4193      several times.
4194      This bug should be fixed in assembler, but a check is also needed here.  */
4195   if (howto->partial_inplace)
4196     x = ((x & ~howto->dst_mask)
4197          | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4198   else
4199     x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4200
4201
4202   /* Put the relocated value back in the object file.  */
4203   switch (size)
4204     {
4205     default:
4206     case 0:
4207     case 1:
4208     case 8:
4209       abort ();
4210       break;
4211     case 2:
4212       bfd_putb16 (x, location);
4213       break;
4214     case 4:
4215       bfd_putb32 (x, location);
4216       break;
4217     }
4218
4219   return flag;
4220 }
4221
4222 static bfd_reloc_status_type
4223 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4224                                asection *input_section, bfd_byte *contents,
4225                                bfd_vma address, bfd_vma value, bfd_vma addend)
4226 {
4227   bfd_vma relocation;
4228
4229   /* Sanity check the address.  */
4230   if (address > bfd_get_section_limit (input_bfd, input_section))
4231     return bfd_reloc_outofrange;
4232
4233   /* This function assumes that we are dealing with a basic relocation
4234      against a symbol.  We want to compute the value of the symbol to
4235      relocate to.  This is just VALUE, the value of the symbol, plus
4236      ADDEND, any addend associated with the reloc.  */
4237   relocation = value + addend;
4238
4239   /* If the relocation is PC relative, we want to set RELOCATION to
4240      the distance between the symbol (currently in RELOCATION) and the
4241      location we are relocating.  Some targets (e.g., i386-aout)
4242      arrange for the contents of the section to be the negative of the
4243      offset of the location within the section; for such targets
4244      pcrel_offset is FALSE.  Other targets (e.g., m88kbcs or ELF)
4245      simply leave the contents of the section as zero; for such
4246      targets pcrel_offset is TRUE.  If pcrel_offset is FALSE we do not
4247      need to subtract out the offset of the location within the
4248      section (which is just ADDRESS).  */
4249   if (howto->pc_relative)
4250     {
4251       relocation -= (input_section->output_section->vma
4252                      + input_section->output_offset);
4253       if (howto->pcrel_offset)
4254         relocation -= address;
4255     }
4256
4257   return nds32_relocate_contents (howto, input_bfd, relocation,
4258                                   contents + address);
4259 }
4260
4261 static bfd_boolean
4262 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4263                               const char *name,
4264                               Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4265                               asection *input_sec,
4266                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4267 {
4268   const char *source;
4269   FILE *sym_ld_script = NULL;
4270   struct elf_nds32_link_hash_table *table;
4271
4272   table = nds32_elf_hash_table (info);
4273   sym_ld_script = table->sym_ld_script;
4274   if (!sym_ld_script)
4275     return TRUE;
4276
4277   if (!h || !name || *name == '\0')
4278     return TRUE;
4279
4280   if (input_sec->flags & SEC_EXCLUDE)
4281     return TRUE;
4282
4283   if (!check_start_export_sym)
4284     {
4285       fprintf (sym_ld_script, "SECTIONS\n{\n");
4286       check_start_export_sym = 1;
4287     }
4288
4289   if (h->root.type == bfd_link_hash_defined
4290       || h->root.type == bfd_link_hash_defweak)
4291     {
4292       if (!h->root.u.def.section->output_section)
4293         return TRUE;
4294
4295       if (bfd_is_const_section (input_sec))
4296         source = input_sec->name;
4297       else
4298         source = input_sec->owner->filename;
4299
4300       fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4301                h->root.root.string,
4302                (long) (h->root.u.def.value
4303                 + h->root.u.def.section->output_section->vma
4304                 + h->root.u.def.section->output_offset), source);
4305     }
4306
4307   return TRUE;
4308 }
4309
4310 /* Relocate an NDS32/D ELF section.
4311    There is some attempt to make this function usable for many architectures,
4312    both for RELA and REL type relocs, if only to serve as a learning tool.
4313
4314    The RELOCATE_SECTION function is called by the new ELF backend linker
4315    to handle the relocations for a section.
4316
4317    The relocs are always passed as Rela structures; if the section
4318    actually uses Rel structures, the r_addend field will always be
4319    zero.
4320
4321    This function is responsible for adjust the section contents as
4322    necessary, and (if using Rela relocs and generating a
4323    relocatable output file) adjusting the reloc addend as
4324    necessary.
4325
4326    This function does not have to worry about setting the reloc
4327    address or the reloc symbol index.
4328
4329    LOCAL_SYMS is a pointer to the swapped in local symbols.
4330
4331    LOCAL_SECTIONS is an array giving the section in the input file
4332    corresponding to the st_shndx field of each local symbol.
4333
4334    The global hash table entry for the global symbols can be found
4335    via elf_sym_hashes (input_bfd).
4336
4337    When generating relocatable output, this function must handle
4338    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
4339    going to be the section symbol corresponding to the output
4340    section, which means that the addend must be adjusted
4341    accordingly.  */
4342
4343 static bfd_vma
4344 dtpoff_base (struct bfd_link_info *info)
4345 {
4346   /* If tls_sec is NULL, we should have signalled an error already.  */
4347   if (elf_hash_table (info)->tls_sec == NULL)
4348     return 0;
4349   return elf_hash_table (info)->tls_sec->vma;
4350 }
4351
4352 static bfd_boolean
4353 nds32_elf_relocate_section (bfd *                  output_bfd ATTRIBUTE_UNUSED,
4354                             struct bfd_link_info * info,
4355                             bfd *                  input_bfd,
4356                             asection *             input_section,
4357                             bfd_byte *             contents,
4358                             Elf_Internal_Rela *    relocs,
4359                             Elf_Internal_Sym *     local_syms,
4360                             asection **            local_sections)
4361 {
4362   Elf_Internal_Shdr *symtab_hdr;
4363   struct elf_link_hash_entry **sym_hashes;
4364   Elf_Internal_Rela *rel, *relend;
4365   bfd_boolean ret = TRUE;               /* Assume success.  */
4366   int align = 0;
4367   bfd_reloc_status_type r;
4368   const char *errmsg = NULL;
4369   bfd_vma gp;
4370   struct elf_nds32_link_hash_table *htab;
4371   bfd *dynobj;
4372   bfd_vma *local_got_offsets;
4373   asection *sgot, *splt, *sreloc;
4374   bfd_vma high_address;
4375   struct elf_nds32_link_hash_table *table;
4376   int eliminate_gc_relocs;
4377   bfd_vma fpbase_addr;
4378
4379   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4380   sym_hashes = elf_sym_hashes (input_bfd);
4381   htab = nds32_elf_hash_table (info);
4382   high_address = bfd_get_section_limit (input_bfd, input_section);
4383
4384   dynobj = htab->root.dynobj;
4385   local_got_offsets = elf_local_got_offsets (input_bfd);
4386
4387   sgot = htab->root.sgot;
4388   splt = htab->root.splt;
4389   sreloc = NULL;
4390
4391   rel = relocs;
4392   relend = relocs + input_section->reloc_count;
4393
4394   table = nds32_elf_hash_table (info);
4395   eliminate_gc_relocs = table->eliminate_gc_relocs;
4396   /* By this time, we can adjust the value of _SDA_BASE_.  */
4397   if ((!bfd_link_relocatable (info)))
4398     {
4399       is_SDA_BASE_set = 1;
4400       r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4401       if (r != bfd_reloc_ok)
4402         return FALSE;
4403     }
4404
4405   if (is_ITB_BASE_set == 0)
4406     {
4407       /* Set the _ITB_BASE_.  */
4408       if (!nds32_elf_ex9_itb_base (info))
4409         {
4410           _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"),
4411                               output_bfd);
4412           bfd_set_error (bfd_error_bad_value);
4413         }
4414     }
4415
4416   if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4417     if (!nds32_elf_ifc_reloc ())
4418       _bfd_error_handler (_("error: IFC relocation error."));
4419
4420  /* Relocation for .ex9.itable.  */
4421   if (table->target_optimize & NDS32_RELAX_EX9_ON
4422       || (table->ex9_import_file && table->update_ex9_table))
4423     nds32_elf_ex9_reloc_jmp (info);
4424
4425   /* Use gp as fp to prevent truncated fit.  Because in relaxation time
4426      the fp value is set as gp, and it has be reverted for instruction
4427      setting fp.  */
4428   fpbase_addr = elf_gp (output_bfd);
4429
4430   for (rel = relocs; rel < relend; rel++)
4431     {
4432       enum elf_nds32_reloc_type r_type;
4433       reloc_howto_type *howto = NULL;
4434       unsigned long r_symndx;
4435       struct elf_link_hash_entry *h = NULL;
4436       Elf_Internal_Sym *sym = NULL;
4437       asection *sec;
4438       bfd_vma relocation;
4439
4440       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4441          ensure it's zero (we use REL relocs, not RELA).  Therefore this
4442          should be assigning zero to `addend', but for clarity we use
4443          `r_addend'.  */
4444
4445       bfd_vma addend = rel->r_addend;
4446       bfd_vma offset = rel->r_offset;
4447
4448       r_type = ELF32_R_TYPE (rel->r_info);
4449       if (r_type >= R_NDS32_max)
4450         {
4451           /* xgettext:c-format */
4452           _bfd_error_handler (_("%B: error: unknown relocation type %d."),
4453                               input_bfd, r_type);
4454           bfd_set_error (bfd_error_bad_value);
4455           ret = FALSE;
4456           continue;
4457         }
4458
4459       if (r_type == R_NDS32_GNU_VTENTRY
4460           || r_type == R_NDS32_GNU_VTINHERIT
4461           || r_type == R_NDS32_NONE
4462           || r_type == R_NDS32_RELA_GNU_VTENTRY
4463           || r_type == R_NDS32_RELA_GNU_VTINHERIT
4464           || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4465           || r_type == R_NDS32_DATA
4466           || r_type == R_NDS32_TRAN
4467           || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP7))
4468         continue;
4469
4470       /* If we enter the fp-as-gp region.  Resolve the address
4471          of best fp-base.  */
4472       if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4473           && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4474         {
4475           int dist;
4476
4477           /* Distance to relocation of best fp-base is encoded in R_SYM.  */
4478           dist =  rel->r_addend >> 16;
4479           fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4480                                                   local_syms, symtab_hdr);
4481         }
4482       else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4483                && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4484         {
4485           fpbase_addr = elf_gp (output_bfd);
4486         }
4487
4488       if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4489             && r_type <= R_NDS32_DWARF2_LEB_RELA)
4490            || r_type >= R_NDS32_RELAX_ENTRY) && !bfd_link_relocatable (info))
4491         continue;
4492
4493       howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4494       r_symndx = ELF32_R_SYM (rel->r_info);
4495
4496       /* This is a final link.  */
4497       sym = NULL;
4498       sec = NULL;
4499       h = NULL;
4500
4501       if (r_symndx < symtab_hdr->sh_info)
4502         {
4503           /* Local symbol.  */
4504           sym = local_syms + r_symndx;
4505           sec = local_sections[r_symndx];
4506
4507           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4508           addend = rel->r_addend;
4509         }
4510       else
4511         {
4512           /* External symbol.  */
4513           bfd_boolean warned, ignored, unresolved_reloc;
4514           int symndx = r_symndx - symtab_hdr->sh_info;
4515
4516           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4517                                    r_symndx, symtab_hdr, sym_hashes, h, sec,
4518                                    relocation, unresolved_reloc, warned,
4519                                    ignored);
4520
4521           /* la $fp, _FP_BASE_ is per-function (region).
4522              Handle it specially.  */
4523           switch ((int) r_type)
4524             {
4525             case R_NDS32_SDA19S0_RELA:
4526             case R_NDS32_SDA15S0_RELA:
4527             case R_NDS32_20_RELA:
4528               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4529                           FP_BASE_NAME) == 0)
4530                 {
4531                   relocation = fpbase_addr;
4532                   break;
4533                 }
4534             }
4535
4536         }
4537
4538       if (bfd_link_relocatable (info))
4539         {
4540           /* This is a relocatable link.  We don't have to change
4541              anything, unless the reloc is against a section symbol,
4542              in which case we have to adjust according to where the
4543              section symbol winds up in the output section.  */
4544           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4545             rel->r_addend += sec->output_offset + sym->st_value;
4546
4547           continue;
4548         }
4549
4550       /* Sanity check the address.  */
4551       if (offset > high_address)
4552         {
4553           r = bfd_reloc_outofrange;
4554           goto check_reloc;
4555         }
4556
4557       if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4558            && r_type <= R_NDS32_DWARF2_LEB_RELA)
4559           || r_type >= R_NDS32_RELAX_ENTRY)
4560         continue;
4561
4562       switch ((int) r_type)
4563         {
4564         case R_NDS32_GOTOFF:
4565           /* Relocation is relative to the start of the global offset
4566              table (for ld24 rx, #uimm24), e.g. access at label+addend
4567
4568              ld24 rx. #label@GOTOFF + addend
4569              sub  rx, r12.  */
4570         case R_NDS32_GOTOFF_HI20:
4571         case R_NDS32_GOTOFF_LO12:
4572         case R_NDS32_GOTOFF_LO15:
4573         case R_NDS32_GOTOFF_LO19:
4574           BFD_ASSERT (sgot != NULL);
4575
4576           relocation -= elf_gp (output_bfd);
4577           break;
4578
4579         case R_NDS32_9_PLTREL:
4580         case R_NDS32_25_PLTREL:
4581           /* Relocation is to the entry for this symbol in the
4582              procedure linkage table.  */
4583
4584           /* The native assembler will generate a 25_PLTREL reloc
4585              for a local symbol if you assemble a call from one
4586              section to another when using -K pic.  */
4587           if (h == NULL)
4588             break;
4589
4590           if (h->forced_local)
4591             break;
4592
4593           /* We didn't make a PLT entry for this symbol.  This
4594              happens when statically linking PIC code, or when
4595              using -Bsymbolic.  */
4596           if (h->plt.offset == (bfd_vma) - 1)
4597             break;
4598
4599           relocation = (splt->output_section->vma
4600                         + splt->output_offset + h->plt.offset);
4601           break;
4602
4603         case R_NDS32_PLT_GOTREL_HI20:
4604         case R_NDS32_PLT_GOTREL_LO12:
4605         case R_NDS32_PLT_GOTREL_LO15:
4606         case R_NDS32_PLT_GOTREL_LO19:
4607         case R_NDS32_PLT_GOTREL_LO20:
4608           if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4609             {
4610               /* We didn't make a PLT entry for this symbol.  This
4611                  happens when statically linking PIC code, or when
4612                  using -Bsymbolic.  */
4613               relocation -= elf_gp (output_bfd);
4614               break;
4615             }
4616
4617           relocation = (splt->output_section->vma
4618                         + splt->output_offset + h->plt.offset);
4619
4620           relocation -= elf_gp (output_bfd);
4621           break;
4622
4623         case R_NDS32_PLTREL_HI20:
4624         case R_NDS32_PLTREL_LO12:
4625
4626           /* Relocation is to the entry for this symbol in the
4627              procedure linkage table.  */
4628
4629           /* The native assembler will generate a 25_PLTREL reloc
4630              for a local symbol if you assemble a call from one
4631              section to another when using -K pic.  */
4632           if (h == NULL)
4633             break;
4634
4635           if (h->forced_local)
4636             break;
4637
4638           if (h->plt.offset == (bfd_vma) - 1)
4639             /* We didn't make a PLT entry for this symbol.  This
4640                happens when statically linking PIC code, or when
4641                using -Bsymbolic.  */
4642             break;
4643
4644           if (splt == NULL)
4645             break;
4646
4647           relocation = (splt->output_section->vma
4648                         + splt->output_offset
4649                         + h->plt.offset + 4)
4650                        - (input_section->output_section->vma
4651                           + input_section->output_offset
4652                           + rel->r_offset);
4653
4654           break;
4655
4656         case R_NDS32_GOTPC20:
4657           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4658              ld24 rx,#_GLOBAL_OFFSET_TABLE_  */
4659           relocation = elf_gp (output_bfd);
4660           break;
4661
4662         case R_NDS32_GOTPC_HI20:
4663         case R_NDS32_GOTPC_LO12:
4664             {
4665               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4666                  bl .+4
4667                  seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4668                  or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4669                  or
4670                  bl .+4
4671                  seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4672                  add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4673                */
4674               relocation = elf_gp (output_bfd);
4675               relocation -= (input_section->output_section->vma
4676                              + input_section->output_offset + rel->r_offset);
4677               break;
4678             }
4679
4680         case R_NDS32_GOT20:
4681           /* Fall through.  */
4682         case R_NDS32_GOT_HI20:
4683         case R_NDS32_GOT_LO12:
4684         case R_NDS32_GOT_LO15:
4685         case R_NDS32_GOT_LO19:
4686           /* Relocation is to the entry for this symbol in the global
4687              offset table.  */
4688           BFD_ASSERT (sgot != NULL);
4689
4690           if (h != NULL)
4691             {
4692               bfd_boolean dyn;
4693               bfd_vma off;
4694
4695               off = h->got.offset;
4696               BFD_ASSERT (off != (bfd_vma) - 1);
4697               dyn = htab->root.dynamic_sections_created;
4698               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4699                                                     bfd_link_pic (info),
4700                                                     h)
4701                   || (bfd_link_pic (info)
4702                       && (info->symbolic
4703                           || h->dynindx == -1
4704                           || h->forced_local) && h->def_regular))
4705                 {
4706                   /* This is actually a static link, or it is a
4707                      -Bsymbolic link and the symbol is defined
4708                      locally, or the symbol was forced to be local
4709                      because of a version file.  We must initialize
4710                      this entry in the global offset table.  Since the
4711                      offset must always be a multiple of 4, we use the
4712                      least significant bit to record whether we have
4713                      initialized it already.
4714
4715                      When doing a dynamic link, we create a .rela.got
4716                      relocation entry to initialize the value.  This
4717                      is done in the finish_dynamic_symbol routine.  */
4718                   if ((off & 1) != 0)
4719                     off &= ~1;
4720                   else
4721                     {
4722                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4723                       h->got.offset |= 1;
4724                     }
4725                 }
4726               relocation = sgot->output_section->vma + sgot->output_offset + off
4727                            - elf_gp (output_bfd);
4728             }
4729           else
4730             {
4731               bfd_vma off;
4732               bfd_byte *loc;
4733
4734               BFD_ASSERT (local_got_offsets != NULL
4735                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4736
4737               off = local_got_offsets[r_symndx];
4738
4739               /* The offset must always be a multiple of 4.  We use
4740                  the least significant bit to record whether we have
4741                  already processed this entry.  */
4742               if ((off & 1) != 0)
4743                 off &= ~1;
4744               else
4745                 {
4746                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4747
4748                   if (bfd_link_pic (info))
4749                     {
4750                       asection *srelgot;
4751                       Elf_Internal_Rela outrel;
4752
4753                       /* We need to generate a R_NDS32_RELATIVE reloc
4754                          for the dynamic linker.  */
4755                       srelgot = htab->root.srelgot;
4756                       BFD_ASSERT (srelgot != NULL);
4757
4758                       outrel.r_offset = (elf_gp (output_bfd)
4759                                          + sgot->output_offset + off);
4760                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4761                       outrel.r_addend = relocation;
4762                       loc = srelgot->contents;
4763                       loc +=
4764                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
4765                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4766                       ++srelgot->reloc_count;
4767                     }
4768                   local_got_offsets[r_symndx] |= 1;
4769                 }
4770               relocation = sgot->output_section->vma + sgot->output_offset + off
4771                            - elf_gp (output_bfd);
4772             }
4773
4774           break;
4775
4776         case R_NDS32_16_RELA:
4777         case R_NDS32_20_RELA:
4778         case R_NDS32_5_RELA:
4779         case R_NDS32_32_RELA:
4780         case R_NDS32_9_PCREL_RELA:
4781         case R_NDS32_WORD_9_PCREL_RELA:
4782         case R_NDS32_10_UPCREL_RELA:
4783         case R_NDS32_15_PCREL_RELA:
4784         case R_NDS32_17_PCREL_RELA:
4785         case R_NDS32_25_PCREL_RELA:
4786         case R_NDS32_HI20_RELA:
4787         case R_NDS32_LO12S3_RELA:
4788         case R_NDS32_LO12S2_RELA:
4789         case R_NDS32_LO12S2_DP_RELA:
4790         case R_NDS32_LO12S2_SP_RELA:
4791         case R_NDS32_LO12S1_RELA:
4792         case R_NDS32_LO12S0_RELA:
4793         case R_NDS32_LO12S0_ORI_RELA:
4794           if (bfd_link_pic (info) && r_symndx != 0
4795               && (input_section->flags & SEC_ALLOC) != 0
4796               && (eliminate_gc_relocs == 0
4797                   || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4798               && ((r_type != R_NDS32_9_PCREL_RELA
4799                    && r_type != R_NDS32_WORD_9_PCREL_RELA
4800                    && r_type != R_NDS32_10_UPCREL_RELA
4801                    && r_type != R_NDS32_15_PCREL_RELA
4802                    && r_type != R_NDS32_17_PCREL_RELA
4803                    && r_type != R_NDS32_25_PCREL_RELA
4804                    && !(r_type == R_NDS32_32_RELA
4805                         && strcmp (input_section->name, ".eh_frame") == 0))
4806                   || (h != NULL && h->dynindx != -1
4807                       && (!info->symbolic || !h->def_regular))))
4808             {
4809               Elf_Internal_Rela outrel;
4810               bfd_boolean skip, relocate;
4811               bfd_byte *loc;
4812
4813               /* When generating a shared object, these relocations
4814                  are copied into the output file to be resolved at run
4815                  time.  */
4816
4817               if (sreloc == NULL)
4818                 {
4819                   const char *name;
4820
4821                   name = bfd_elf_string_from_elf_section
4822                     (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4823                      elf_section_data (input_section)->rela.hdr->sh_name);
4824                   if (name == NULL)
4825                     return FALSE;
4826
4827                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4828                               && strcmp (bfd_get_section_name (input_bfd,
4829                                                                input_section),
4830                                          name + 5) == 0);
4831
4832                   sreloc = bfd_get_section_by_name (dynobj, name);
4833                   BFD_ASSERT (sreloc != NULL);
4834                 }
4835
4836               skip = FALSE;
4837               relocate = FALSE;
4838
4839               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4840                                                          info,
4841                                                          input_section,
4842                                                          rel->r_offset);
4843               if (outrel.r_offset == (bfd_vma) - 1)
4844                 skip = TRUE;
4845               else if (outrel.r_offset == (bfd_vma) - 2)
4846                 skip = TRUE, relocate = TRUE;
4847               outrel.r_offset += (input_section->output_section->vma
4848                                   + input_section->output_offset);
4849
4850               if (skip)
4851                 memset (&outrel, 0, sizeof outrel);
4852               else if (r_type == R_NDS32_17_PCREL_RELA
4853                        || r_type == R_NDS32_15_PCREL_RELA
4854                        || r_type == R_NDS32_25_PCREL_RELA)
4855                 {
4856                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4857                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4858                   outrel.r_addend = rel->r_addend;
4859                 }
4860               else
4861                 {
4862                   /* h->dynindx may be -1 if this symbol was marked to
4863                      become local.  */
4864                   if (h == NULL
4865                       || ((info->symbolic || h->dynindx == -1)
4866                           && h->def_regular))
4867                     {
4868                       relocate = TRUE;
4869                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4870                       outrel.r_addend = relocation + rel->r_addend;
4871                     }
4872                   else
4873                     {
4874                       BFD_ASSERT (h->dynindx != -1);
4875                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4876                       outrel.r_addend = rel->r_addend;
4877                     }
4878                 }
4879
4880               loc = sreloc->contents;
4881               loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4882               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4883               ++sreloc->reloc_count;
4884
4885               /* If this reloc is against an external symbol, we do
4886                  not want to fiddle with the addend.  Otherwise, we
4887                  need to include the symbol value so that it becomes
4888                  an addend for the dynamic reloc.  */
4889               if (!relocate)
4890                 continue;
4891             }
4892           break;
4893
4894         case R_NDS32_25_ABS_RELA:
4895           if (bfd_link_pic (info))
4896             {
4897               _bfd_error_handler
4898                 (_("%B: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
4899                    "mode."), input_bfd);
4900               return FALSE;
4901             }
4902           break;
4903
4904         case R_NDS32_9_PCREL:
4905           r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
4906                                           contents, offset,
4907                                           sec, relocation, addend);
4908           goto check_reloc;
4909
4910         case R_NDS32_HI20:
4911             {
4912               Elf_Internal_Rela *lorel;
4913
4914               /* We allow an arbitrary number of HI20 relocs before the
4915                  LO12 reloc.  This permits gcc to emit the HI and LO relocs
4916                  itself.  */
4917               for (lorel = rel + 1;
4918                    (lorel < relend
4919                     && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
4920                 continue;
4921               if (lorel < relend
4922                   && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
4923                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
4924                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
4925                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
4926                 {
4927                   nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
4928                                            contents, relocation + addend);
4929                   r = bfd_reloc_ok;
4930                 }
4931               else
4932                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4933                                               contents, offset, relocation,
4934                                               addend);
4935             }
4936
4937           goto check_reloc;
4938
4939         case R_NDS32_GOT17S2_RELA:
4940         case R_NDS32_GOT15S2_RELA:
4941             {
4942               bfd_vma off;
4943
4944               BFD_ASSERT (sgot != NULL);
4945
4946               if (h != NULL)
4947                 {
4948                   bfd_boolean dyn;
4949
4950                   off = h->got.offset;
4951                   BFD_ASSERT (off != (bfd_vma) - 1);
4952
4953                   dyn = htab->root.dynamic_sections_created;
4954                   if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
4955                       (dyn, bfd_link_pic (info), h)
4956                       || (bfd_link_pic (info)
4957                           && (info->symbolic
4958                               || h->dynindx == -1
4959                               || h->forced_local)
4960                           && h->def_regular))
4961                     {
4962                       /* This is actually a static link, or it is a
4963                          -Bsymbolic link and the symbol is defined
4964                          locally, or the symbol was forced to be local
4965                          because of a version file.  We must initialize
4966                          this entry in the global offset table.  Since the
4967                          offset must always be a multiple of 4, we use the
4968                          least significant bit to record whether we have
4969                          initialized it already.
4970
4971                          When doing a dynamic link, we create a .rela.got
4972                          relocation entry to initialize the value.  This
4973                          is done in the finish_dynamic_symbol routine.  */
4974                       if ((off & 1) != 0)
4975                         off &= ~1;
4976                       else
4977                         {
4978                           bfd_put_32 (output_bfd, relocation,
4979                                       sgot->contents + off);
4980                           h->got.offset |= 1;
4981                         }
4982                     }
4983                 }
4984               else
4985                 {
4986                   bfd_byte *loc;
4987
4988                   BFD_ASSERT (local_got_offsets != NULL
4989                               && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4990
4991                   off = local_got_offsets[r_symndx];
4992
4993                   /* The offset must always be a multiple of 4.  We use
4994                      the least significant bit to record whether we have
4995                      already processed this entry.  */
4996                   if ((off & 1) != 0)
4997                     off &= ~1;
4998                   else
4999                     {
5000                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5001
5002                       if (bfd_link_pic (info))
5003                         {
5004                           asection *srelgot;
5005                           Elf_Internal_Rela outrel;
5006
5007                           /* We need to generate a R_NDS32_RELATIVE reloc
5008                              for the dynamic linker.  */
5009                           srelgot = htab->root.srelgot;
5010                           BFD_ASSERT (srelgot != NULL);
5011
5012                           outrel.r_offset = (elf_gp (output_bfd)
5013                                              + sgot->output_offset + off);
5014                           outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5015                           outrel.r_addend = relocation;
5016                           loc = srelgot->contents;
5017                           loc +=
5018                             srelgot->reloc_count * sizeof (Elf32_External_Rela);
5019                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5020                           ++srelgot->reloc_count;
5021                         }
5022                       local_got_offsets[r_symndx] |= 1;
5023                     }
5024                 }
5025               relocation = sgot->output_section->vma + sgot->output_offset + off
5026                            - elf_gp (output_bfd);
5027             }
5028           if (relocation & align)
5029             {
5030               /* Incorrect alignment.  */
5031               _bfd_error_handler
5032                 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5033               ret = FALSE;
5034               r = bfd_reloc_dangerous;
5035               goto check_reloc;
5036             }
5037           break;
5038
5039         case R_NDS32_SDA16S3_RELA:
5040         case R_NDS32_SDA15S3_RELA:
5041         case R_NDS32_SDA15S3:
5042           align = 0x7;
5043           goto handle_sda;
5044
5045         case R_NDS32_SDA17S2_RELA:
5046         case R_NDS32_SDA15S2_RELA:
5047         case R_NDS32_SDA12S2_SP_RELA:
5048         case R_NDS32_SDA12S2_DP_RELA:
5049         case R_NDS32_SDA15S2:
5050         case R_NDS32_SDA_FP7U2_RELA:
5051           align = 0x3;
5052           goto handle_sda;
5053
5054         case R_NDS32_SDA18S1_RELA:
5055         case R_NDS32_SDA15S1_RELA:
5056         case R_NDS32_SDA15S1:
5057           align = 0x1;
5058           goto handle_sda;
5059
5060         case R_NDS32_SDA19S0_RELA:
5061         case R_NDS32_SDA15S0_RELA:
5062         case R_NDS32_SDA15S0:
5063             {
5064               align = 0x0;
5065 handle_sda:
5066               BFD_ASSERT (sec != NULL);
5067
5068               /* If the symbol is in the abs section, the out_bfd will be null.
5069                  This happens when the relocation has a symbol@GOTOFF.  */
5070               r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5071               if (r != bfd_reloc_ok)
5072                 {
5073                   _bfd_error_handler
5074                     (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5075                   ret = FALSE;
5076                   goto check_reloc;
5077                 }
5078
5079               /* At this point `relocation' contains the object's
5080                  address.  */
5081               if (r_type == R_NDS32_SDA_FP7U2_RELA)
5082                 {
5083                   relocation -= fpbase_addr;
5084                 }
5085               else
5086                 relocation -= gp;
5087               /* Now it contains the offset from _SDA_BASE_.  */
5088
5089               /* Make sure alignment is correct.  */
5090
5091               if (relocation & align)
5092                 {
5093                   /* Incorrect alignment.  */
5094                   _bfd_error_handler
5095                     /* xgettext:c-format */
5096                     (_("%B(%A): warning: unaligned small data access of type %d."),
5097                      input_bfd, input_section, r_type);
5098                   ret = FALSE;
5099                   goto check_reloc;
5100                 }
5101             }
5102
5103           break;
5104         case R_NDS32_17IFC_PCREL_RELA:
5105         case R_NDS32_10IFCU_PCREL_RELA:
5106           /* do nothing */
5107           break;
5108
5109         case R_NDS32_TLS_LE_HI20:
5110         case R_NDS32_TLS_LE_LO12:
5111         case R_NDS32_TLS_LE_20:
5112         case R_NDS32_TLS_LE_15S0:
5113         case R_NDS32_TLS_LE_15S1:
5114         case R_NDS32_TLS_LE_15S2:
5115           if (elf_hash_table (info)->tls_sec != NULL)
5116             relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5117           break;
5118         case R_NDS32_TLS_IE_HI20:
5119         case R_NDS32_TLS_IE_LO12S2:
5120           {
5121             /* Relocation is to the entry for this symbol in the global
5122                offset table.  */
5123             unsigned int tls_type;
5124             asection *srelgot;
5125             Elf_Internal_Rela outrel;
5126             bfd_vma off;
5127             bfd_byte *loc;
5128             int indx = 0;
5129
5130             BFD_ASSERT (sgot != NULL);
5131             if (h != NULL)
5132               {
5133                 bfd_boolean dyn;
5134
5135                 off = h->got.offset;
5136                 BFD_ASSERT (off != (bfd_vma) - 1);
5137                 dyn = htab->root.dynamic_sections_created;
5138                 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5139                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5140                     && (!bfd_link_pic (info)
5141                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
5142                   indx = h->dynindx;
5143               }
5144             else
5145               {
5146                 /* Never happen currently.  */
5147                 BFD_ASSERT (local_got_offsets != NULL
5148                             && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5149
5150                 off = local_got_offsets[r_symndx];
5151
5152                 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5153               }
5154             relocation = sgot->output_section->vma + sgot->output_offset + off;
5155
5156             if (r_type == R_NDS32_TLS_IE_LO12S2)
5157               break;
5158
5159             /* The offset must always be a multiple of 4.  We use
5160                the least significant bit to record whether we have
5161                already processed this entry.  */
5162             if ((off & 1) != 0)
5163               off &= ~1;
5164             else
5165               {
5166                 bfd_boolean need_relocs = FALSE;
5167                 srelgot = htab->root.srelgot;
5168                 if ((bfd_link_pic (info) || indx != 0)
5169                     && (h == NULL
5170                         || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5171                         || h->root.type != bfd_link_hash_undefweak))
5172                   {
5173                     need_relocs = TRUE;
5174                     BFD_ASSERT (srelgot != NULL);
5175                   }
5176                 if (tls_type & GOT_TLS_IE)
5177                   {
5178                     if (need_relocs)
5179                       {
5180                         if (h->dynindx == 0)
5181                           outrel.r_addend = relocation - dtpoff_base (info);
5182                         else
5183                           outrel.r_addend = 0;
5184                         outrel.r_offset = (sgot->output_section->vma
5185                                            + sgot->output_offset
5186                                            + off);
5187                         outrel.r_info =
5188                           ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5189
5190                         loc = srelgot->contents;
5191                         loc +=
5192                           srelgot->reloc_count * sizeof (Elf32_External_Rela);
5193                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5194                         ++srelgot->reloc_count;
5195                       }
5196                     else
5197                       bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5198                                   sgot->contents + off);
5199                   }
5200               }
5201           }
5202         break;
5203
5204           /* DON'T   fall through.  */
5205
5206         default:
5207           /* OLD_NDS32_RELOC.  */
5208
5209           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5210                                         contents, offset, relocation, addend);
5211           goto check_reloc;
5212         }
5213
5214       switch ((int) r_type)
5215         {
5216         case R_NDS32_20_RELA:
5217         case R_NDS32_5_RELA:
5218         case R_NDS32_9_PCREL_RELA:
5219         case R_NDS32_WORD_9_PCREL_RELA:
5220         case R_NDS32_10_UPCREL_RELA:
5221         case R_NDS32_15_PCREL_RELA:
5222         case R_NDS32_17_PCREL_RELA:
5223         case R_NDS32_25_PCREL_RELA:
5224         case R_NDS32_25_ABS_RELA:
5225         case R_NDS32_HI20_RELA:
5226         case R_NDS32_LO12S3_RELA:
5227         case R_NDS32_LO12S2_RELA:
5228         case R_NDS32_LO12S2_DP_RELA:
5229         case R_NDS32_LO12S2_SP_RELA:
5230         case R_NDS32_LO12S1_RELA:
5231         case R_NDS32_LO12S0_RELA:
5232         case R_NDS32_LO12S0_ORI_RELA:
5233         case R_NDS32_SDA16S3_RELA:
5234         case R_NDS32_SDA17S2_RELA:
5235         case R_NDS32_SDA18S1_RELA:
5236         case R_NDS32_SDA19S0_RELA:
5237         case R_NDS32_SDA15S3_RELA:
5238         case R_NDS32_SDA15S2_RELA:
5239         case R_NDS32_SDA12S2_DP_RELA:
5240         case R_NDS32_SDA12S2_SP_RELA:
5241         case R_NDS32_SDA15S1_RELA:
5242         case R_NDS32_SDA15S0_RELA:
5243         case R_NDS32_SDA_FP7U2_RELA:
5244         case R_NDS32_9_PLTREL:
5245         case R_NDS32_25_PLTREL:
5246         case R_NDS32_GOT20:
5247         case R_NDS32_GOT_HI20:
5248         case R_NDS32_GOT_LO12:
5249         case R_NDS32_GOT_LO15:
5250         case R_NDS32_GOT_LO19:
5251         case R_NDS32_GOT15S2_RELA:
5252         case R_NDS32_GOT17S2_RELA:
5253         case R_NDS32_GOTPC20:
5254         case R_NDS32_GOTPC_HI20:
5255         case R_NDS32_GOTPC_LO12:
5256         case R_NDS32_GOTOFF:
5257         case R_NDS32_GOTOFF_HI20:
5258         case R_NDS32_GOTOFF_LO12:
5259         case R_NDS32_GOTOFF_LO15:
5260         case R_NDS32_GOTOFF_LO19:
5261         case R_NDS32_PLTREL_HI20:
5262         case R_NDS32_PLTREL_LO12:
5263         case R_NDS32_PLT_GOTREL_HI20:
5264         case R_NDS32_PLT_GOTREL_LO12:
5265         case R_NDS32_PLT_GOTREL_LO15:
5266         case R_NDS32_PLT_GOTREL_LO19:
5267         case R_NDS32_PLT_GOTREL_LO20:
5268         case R_NDS32_17IFC_PCREL_RELA:
5269         case R_NDS32_10IFCU_PCREL_RELA:
5270         case R_NDS32_TLS_LE_HI20:
5271         case R_NDS32_TLS_LE_LO12:
5272         case R_NDS32_TLS_IE_HI20:
5273         case R_NDS32_TLS_IE_LO12S2:
5274         case R_NDS32_TLS_LE_20:
5275         case R_NDS32_TLS_LE_15S0:
5276         case R_NDS32_TLS_LE_15S1:
5277         case R_NDS32_TLS_LE_15S2:
5278           /* Instruction related relocs must handle endian properly.  */
5279           /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER.  */
5280           r = nds32_elf_final_link_relocate (howto, input_bfd,
5281                                              input_section, contents,
5282                                              rel->r_offset, relocation,
5283                                              rel->r_addend);
5284           break;
5285
5286         default:
5287           /* All other relocs can use default handler.  */
5288           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5289                                         contents, rel->r_offset,
5290                                         relocation, rel->r_addend);
5291           break;
5292         }
5293
5294 check_reloc:
5295
5296       if (r != bfd_reloc_ok)
5297         {
5298           /* FIXME: This should be generic enough to go in a utility.  */
5299           const char *name;
5300
5301           if (h != NULL)
5302             name = h->root.root.string;
5303           else
5304             {
5305               name = bfd_elf_string_from_elf_section
5306                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
5307               if (name == NULL || *name == '\0')
5308                 name = bfd_section_name (input_bfd, sec);
5309             }
5310
5311           if (errmsg != NULL)
5312             goto common_error;
5313
5314           switch (r)
5315             {
5316             case bfd_reloc_overflow:
5317               (*info->callbacks->reloc_overflow)
5318                 (info, (h ? &h->root : NULL), name, howto->name,
5319                  (bfd_vma) 0, input_bfd, input_section, offset);
5320               break;
5321
5322             case bfd_reloc_undefined:
5323               (*info->callbacks->undefined_symbol)
5324                 (info, name, input_bfd, input_section, offset, TRUE);
5325               break;
5326
5327             case bfd_reloc_outofrange:
5328               errmsg = _("internal error: out of range error");
5329               goto common_error;
5330
5331             case bfd_reloc_notsupported:
5332               errmsg = _("internal error: unsupported relocation error");
5333               goto common_error;
5334
5335             case bfd_reloc_dangerous:
5336               errmsg = _("internal error: dangerous error");
5337               goto common_error;
5338
5339             default:
5340               errmsg = _("internal error: unknown error");
5341               /* Fall through.  */
5342
5343             common_error:
5344               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
5345                                            input_section, offset);
5346               break;
5347             }
5348         }
5349     }
5350
5351   return ret;
5352 }
5353
5354 /* Finish up dynamic symbol handling.  We set the contents of various
5355    dynamic sections here.  */
5356
5357 static bfd_boolean
5358 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5359                                  struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5360 {
5361   struct elf_nds32_link_hash_table *htab;
5362   bfd_byte *loc;
5363
5364   htab = nds32_elf_hash_table (info);
5365
5366   if (h->plt.offset != (bfd_vma) - 1)
5367     {
5368       asection *splt;
5369       asection *sgot;
5370       asection *srela;
5371
5372       bfd_vma plt_index;
5373       bfd_vma got_offset;
5374       bfd_vma local_plt_offset;
5375       Elf_Internal_Rela rela;
5376
5377       /* This symbol has an entry in the procedure linkage table.  Set
5378          it up.  */
5379
5380       BFD_ASSERT (h->dynindx != -1);
5381
5382       splt = htab->root.splt;
5383       sgot = htab->root.sgotplt;
5384       srela = htab->root.srelplt;
5385       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5386
5387       /* Get the index in the procedure linkage table which
5388          corresponds to this symbol.  This is the index of this symbol
5389          in all the symbols for which we are making plt entries.  The
5390          first entry in the procedure linkage table is reserved.  */
5391       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5392
5393       /* Get the offset into the .got table of the entry that
5394          corresponds to this function.  Each .got entry is 4 bytes.
5395          The first three are reserved.  */
5396       got_offset = (plt_index + 3) * 4;
5397
5398       /* Fill in the entry in the procedure linkage table.  */
5399       if (!bfd_link_pic (info))
5400         {
5401           unsigned long insn;
5402
5403           insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5404                                       + sgot->output_offset + got_offset) >> 12)
5405                                     & 0xfffff);
5406           bfd_putb32 (insn, splt->contents + h->plt.offset);
5407
5408           insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5409                                       + sgot->output_offset + got_offset) & 0x0fff)
5410                                     >> 2);
5411           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5412
5413           insn = PLT_ENTRY_WORD2;
5414           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5415
5416           insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5417           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5418
5419           insn = PLT_ENTRY_WORD4
5420                  + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5421           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5422           local_plt_offset = 12;
5423         }
5424       else
5425         {
5426           /* sda_base must be set at this time.  */
5427           unsigned long insn;
5428           long offset;
5429
5430           /* FIXME, sda_base is 65536, it will damage opcode.  */
5431           /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5432           offset = sgot->output_section->vma + sgot->output_offset + got_offset
5433                    - elf_gp (output_bfd);
5434           insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5435           bfd_putb32 (insn, splt->contents + h->plt.offset);
5436
5437           insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5438           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5439
5440           insn = PLT_PIC_ENTRY_WORD2;
5441           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5442
5443           insn = PLT_PIC_ENTRY_WORD3;
5444           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5445
5446           insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5447           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5448
5449           insn = PLT_PIC_ENTRY_WORD5
5450             + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5451           bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5452
5453           local_plt_offset = 16;
5454         }
5455
5456       /* Fill in the entry in the global offset table,
5457          so it will fall through to the next instruction for the first time.  */
5458       bfd_put_32 (output_bfd,
5459                   (splt->output_section->vma + splt->output_offset
5460                    + h->plt.offset + local_plt_offset),
5461                   sgot->contents + got_offset);
5462
5463       /* Fill in the entry in the .rela.plt section.  */
5464       rela.r_offset = (sgot->output_section->vma
5465                        + sgot->output_offset + got_offset);
5466       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5467       rela.r_addend = 0;
5468       loc = srela->contents;
5469       loc += plt_index * sizeof (Elf32_External_Rela);
5470       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5471
5472       if (!h->def_regular)
5473         {
5474           /* Mark the symbol as undefined, rather than as defined in
5475              the .plt section.  Leave the value alone.  */
5476           sym->st_shndx = SHN_UNDEF;
5477           if (!h->ref_regular_nonweak)
5478             sym->st_value = 0;
5479         }
5480     }
5481
5482   if (h->got.offset != (bfd_vma) - 1)
5483     {
5484       asection *sgot;
5485       asection *srela;
5486       Elf_Internal_Rela rela;
5487
5488       /* This symbol has an entry in the global offset table.
5489          Set it up.  */
5490
5491       sgot = htab->root.sgot;
5492       srela = htab->root.srelgot;
5493       BFD_ASSERT (sgot != NULL && srela != NULL);
5494
5495       rela.r_offset = (sgot->output_section->vma
5496                        + sgot->output_offset + (h->got.offset & ~1));
5497
5498       /* If this is a -Bsymbolic link, and the symbol is defined
5499          locally, we just want to emit a RELATIVE reloc.  Likewise if
5500          the symbol was forced to be local because of a version file.
5501          The entry in the global offset table will already have been
5502          initialized in the relocate_section function.  */
5503       if (bfd_link_pic (info)
5504           && (info->symbolic
5505               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5506         {
5507           rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5508           rela.r_addend = (h->root.u.def.value
5509                            + h->root.u.def.section->output_section->vma
5510                            + h->root.u.def.section->output_offset);
5511         }
5512       else
5513         {
5514           BFD_ASSERT ((h->got.offset & 1) == 0);
5515           bfd_put_32 (output_bfd, (bfd_vma) 0,
5516                       sgot->contents + h->got.offset);
5517           rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5518           rela.r_addend = 0;
5519         }
5520
5521       loc = srela->contents;
5522       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5523       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5524       ++srela->reloc_count;
5525     }
5526
5527   if (h->needs_copy)
5528     {
5529       asection *s;
5530       Elf_Internal_Rela rela;
5531
5532       /* This symbols needs a copy reloc.  Set it up.  */
5533
5534       BFD_ASSERT (h->dynindx != -1
5535                   && (h->root.type == bfd_link_hash_defined
5536                       || h->root.type == bfd_link_hash_defweak));
5537
5538       s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5539       BFD_ASSERT (s != NULL);
5540
5541       rela.r_offset = (h->root.u.def.value
5542                        + h->root.u.def.section->output_section->vma
5543                        + h->root.u.def.section->output_offset);
5544       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5545       rela.r_addend = 0;
5546       loc = s->contents;
5547       loc += s->reloc_count * sizeof (Elf32_External_Rela);
5548       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5549       ++s->reloc_count;
5550     }
5551
5552   /* Mark some specially defined symbols as absolute.  */
5553   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5554       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5555     sym->st_shndx = SHN_ABS;
5556
5557   return TRUE;
5558 }
5559
5560
5561 /* Finish up the dynamic sections.  */
5562
5563 static bfd_boolean
5564 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5565 {
5566   struct elf_nds32_link_hash_table *htab;
5567   bfd *dynobj;
5568   asection *sdyn;
5569   asection *sgot;
5570
5571   htab = nds32_elf_hash_table (info);
5572   dynobj = htab->root.dynobj;
5573
5574   sgot = htab->root.sgotplt;
5575   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5576
5577   if (htab->root.dynamic_sections_created)
5578     {
5579       asection *splt;
5580       Elf32_External_Dyn *dyncon, *dynconend;
5581
5582       BFD_ASSERT (sgot != NULL && sdyn != NULL);
5583
5584       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5585       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5586
5587       for (; dyncon < dynconend; dyncon++)
5588         {
5589           Elf_Internal_Dyn dyn;
5590           asection *s;
5591
5592           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5593
5594           switch (dyn.d_tag)
5595             {
5596             default:
5597               break;
5598
5599             case DT_PLTGOT:
5600               s = htab->root.sgotplt;
5601               goto get_vma;
5602             case DT_JMPREL:
5603               s = htab->root.srelplt;
5604             get_vma:
5605               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5606               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5607               break;
5608
5609             case DT_PLTRELSZ:
5610               s = htab->root.srelplt;
5611               dyn.d_un.d_val = s->size;
5612               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5613               break;
5614             }
5615         }
5616
5617       /* Fill in the first entry in the procedure linkage table.  */
5618       splt = htab->root.splt;
5619       if (splt && splt->size > 0)
5620         {
5621           if (bfd_link_pic (info))
5622             {
5623               unsigned long insn;
5624               long offset;
5625
5626               /* FIXME, sda_base is 65536, it will damage opcode.  */
5627               /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5628               offset = sgot->output_section->vma + sgot->output_offset + 4
5629                        - elf_gp (output_bfd);
5630               insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5631               bfd_putb32 (insn, splt->contents);
5632
5633               /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5634               /* here has a typo?  */
5635               insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5636               bfd_putb32 (insn, splt->contents + 4);
5637
5638               insn = PLT0_PIC_ENTRY_WORD2;
5639               bfd_putb32 (insn, splt->contents + 8);
5640
5641               insn = PLT0_PIC_ENTRY_WORD3;
5642               bfd_putb32 (insn, splt->contents + 12);
5643
5644               insn = PLT0_PIC_ENTRY_WORD4;
5645               bfd_putb32 (insn, splt->contents + 16);
5646
5647               insn = PLT0_PIC_ENTRY_WORD5;
5648               bfd_putb32 (insn, splt->contents + 20);
5649             }
5650           else
5651             {
5652               unsigned long insn;
5653               unsigned long addr;
5654
5655               /* addr = .got + 4 */
5656               addr = sgot->output_section->vma + sgot->output_offset + 4;
5657               insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5658               bfd_putb32 (insn, splt->contents);
5659
5660               insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5661               bfd_putb32 (insn, splt->contents + 4);
5662
5663               insn = PLT0_ENTRY_WORD2;
5664               bfd_putb32 (insn, splt->contents + 8);
5665
5666               insn = PLT0_ENTRY_WORD3;
5667               bfd_putb32 (insn, splt->contents + 12);
5668
5669               insn = PLT0_ENTRY_WORD4;
5670               bfd_putb32 (insn, splt->contents + 16);
5671             }
5672
5673           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5674             PLT_ENTRY_SIZE;
5675         }
5676     }
5677
5678   /* Fill in the first three entries in the global offset table.  */
5679   if (sgot && sgot->size > 0)
5680     {
5681       if (sdyn == NULL)
5682         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5683       else
5684         bfd_put_32 (output_bfd,
5685                     sdyn->output_section->vma + sdyn->output_offset,
5686                     sgot->contents);
5687       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5688       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5689
5690       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5691     }
5692
5693   return TRUE;
5694 }
5695 \f
5696
5697 /* Set the right machine number.  */
5698
5699 static bfd_boolean
5700 nds32_elf_object_p (bfd *abfd)
5701 {
5702   static unsigned int cur_arch = 0;
5703
5704   if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5705     {
5706       /* E_N1_ARCH is a wild card, so it is set only when no others exist.  */
5707       cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5708     }
5709
5710   switch (cur_arch)
5711     {
5712     default:
5713     case E_N1_ARCH:
5714       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5715       break;
5716     case E_N1H_ARCH:
5717       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5718       break;
5719     case E_NDS_ARCH_STAR_V2_0:
5720       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5721       break;
5722     case E_NDS_ARCH_STAR_V3_0:
5723       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5724       break;
5725     case E_NDS_ARCH_STAR_V3_M:
5726       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5727       break;
5728     }
5729
5730   return TRUE;
5731 }
5732
5733 /* Store the machine number in the flags field.  */
5734
5735 static void
5736 nds32_elf_final_write_processing (bfd *abfd,
5737                                   bfd_boolean linker ATTRIBUTE_UNUSED)
5738 {
5739   unsigned long val;
5740   static unsigned int cur_mach = 0;
5741
5742   if (bfd_mach_n1 != bfd_get_mach (abfd))
5743     {
5744       cur_mach = bfd_get_mach (abfd);
5745     }
5746
5747   switch (cur_mach)
5748     {
5749     case bfd_mach_n1:
5750       /* Only happen when object is empty, since the case is abandon.  */
5751       val = E_N1_ARCH;
5752       val |= E_NDS_ABI_AABI;
5753       val |= E_NDS32_ELF_VER_1_4;
5754       break;
5755     case bfd_mach_n1h:
5756       val = E_N1H_ARCH;
5757       break;
5758     case bfd_mach_n1h_v2:
5759       val = E_NDS_ARCH_STAR_V2_0;
5760       break;
5761     case bfd_mach_n1h_v3:
5762       val = E_NDS_ARCH_STAR_V3_0;
5763       break;
5764     case bfd_mach_n1h_v3m:
5765       val = E_NDS_ARCH_STAR_V3_M;
5766       break;
5767     default:
5768       val = 0;
5769       break;
5770     }
5771
5772   elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5773   elf_elfheader (abfd)->e_flags |= val;
5774 }
5775
5776 /* Function to keep NDS32 specific file flags.  */
5777
5778 static bfd_boolean
5779 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5780 {
5781   BFD_ASSERT (!elf_flags_init (abfd)
5782               || elf_elfheader (abfd)->e_flags == flags);
5783
5784   elf_elfheader (abfd)->e_flags = flags;
5785   elf_flags_init (abfd) = TRUE;
5786   return TRUE;
5787 }
5788
5789 static unsigned int
5790 convert_e_flags (unsigned int e_flags, unsigned int arch)
5791 {
5792   if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5793     {
5794       /* From 0.9 to 1.0.  */
5795       e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5796
5797       /* Invert E_NDS32_HAS_NO_MAC_INST.  */
5798       e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5799       if (arch == E_NDS_ARCH_STAR_V1_0)
5800         {
5801           /* Done.  */
5802           return e_flags;
5803         }
5804     }
5805
5806   /* From 1.0 to 2.0.  */
5807   e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5808
5809   /* Clear E_NDS32_HAS_MFUSR_PC_INST.  */
5810   e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5811
5812   /* Invert E_NDS32_HAS_NO_MAC_INST.  */
5813   e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5814   return e_flags;
5815 }
5816
5817 static bfd_boolean
5818 nds32_check_vec_size (bfd *ibfd)
5819 {
5820   static unsigned int nds32_vec_size = 0;
5821
5822   asection *sec_t = NULL;
5823   bfd_byte *contents = NULL;
5824
5825   sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5826
5827   if (sec_t && sec_t->size >= 4)
5828     {
5829       /* Get vec_size in file.  */
5830       unsigned int flag_t;
5831
5832       nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
5833       flag_t = bfd_get_32 (ibfd, contents);
5834
5835       /* The value could only be 4 or 16.  */
5836
5837       if (!nds32_vec_size)
5838         /* Set if not set yet.  */
5839         nds32_vec_size = (flag_t & 0x3);
5840       else if (nds32_vec_size != (flag_t & 0x3))
5841         {
5842           _bfd_error_handler
5843             /* xgettext:c-format */
5844             (_("%B: ISR vector size mismatch"
5845                " with previous modules, previous %u-byte, current %u-byte"),
5846              ibfd,
5847              nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5848              (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5849           return FALSE;
5850         }
5851       else
5852         /* Only keep the first vec_size section.  */
5853         sec_t->flags |= SEC_EXCLUDE;
5854     }
5855
5856   return TRUE;
5857 }
5858
5859 /* Merge backend specific data from an object file to the output
5860    object file when linking.  */
5861
5862 static bfd_boolean
5863 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5864 {
5865   bfd *obfd = info->output_bfd;
5866   flagword out_flags;
5867   flagword in_flags;
5868   flagword out_16regs;
5869   flagword in_no_mac;
5870   flagword out_no_mac;
5871   flagword in_16regs;
5872   flagword out_version;
5873   flagword in_version;
5874   flagword out_fpu_config;
5875   flagword in_fpu_config;
5876
5877   /* TODO: Revise to use object-attributes instead.  */
5878   if (!nds32_check_vec_size (ibfd))
5879     return FALSE;
5880
5881   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5882       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5883     return TRUE;
5884
5885   if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
5886     {
5887       _bfd_error_handler
5888         (_("%B: warning: Endian mismatch with previous modules."), ibfd);
5889
5890       bfd_set_error (bfd_error_bad_value);
5891       return FALSE;
5892     }
5893
5894   in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
5895   if (in_version == E_NDS32_ELF_VER_1_2)
5896     {
5897       _bfd_error_handler
5898         (_("%B: warning: Older version of object file encountered, "
5899            "Please recompile with current tool chain."), ibfd);
5900     }
5901
5902   /* We may need to merge V1 and V2 arch object files to V2.  */
5903   if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
5904       != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
5905     {
5906       /* Need to convert version.  */
5907       if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
5908           == E_NDS_ARCH_STAR_RESERVED)
5909         {
5910           elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
5911         }
5912       else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
5913                || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
5914                   > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
5915         {
5916           elf_elfheader (obfd)->e_flags =
5917             convert_e_flags (elf_elfheader (obfd)->e_flags,
5918                              (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
5919         }
5920       else
5921         {
5922           elf_elfheader (ibfd)->e_flags =
5923             convert_e_flags (elf_elfheader (ibfd)->e_flags,
5924                              (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
5925         }
5926     }
5927
5928   /* Extract some flags.  */
5929   in_flags = elf_elfheader (ibfd)->e_flags
5930              & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
5931                   | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
5932
5933   /* The following flags need special treatment.  */
5934   in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
5935   in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
5936   in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
5937
5938   /* Extract some flags.  */
5939   out_flags = elf_elfheader (obfd)->e_flags
5940               & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
5941                    | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
5942
5943   /* The following flags need special treatment.  */
5944   out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
5945   out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
5946   out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
5947   out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
5948   if (!elf_flags_init (obfd))
5949     {
5950       /* If the input is the default architecture then do not
5951          bother setting the flags for the output architecture,
5952          instead allow future merges to do this.  If no future
5953          merges ever set these flags then they will retain their
5954          unitialised values, which surprise surprise, correspond
5955          to the default values.  */
5956       if (bfd_get_arch_info (ibfd)->the_default)
5957         return TRUE;
5958
5959       elf_flags_init (obfd) = TRUE;
5960       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
5961
5962       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5963           && bfd_get_arch_info (obfd)->the_default)
5964         {
5965           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
5966                                     bfd_get_mach (ibfd));
5967         }
5968
5969       return TRUE;
5970     }
5971
5972   /* Check flag compatibility.  */
5973   if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
5974     {
5975       _bfd_error_handler
5976         (_("%B: error: ABI mismatch with previous modules."), ibfd);
5977
5978       bfd_set_error (bfd_error_bad_value);
5979       return FALSE;
5980     }
5981
5982   if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
5983     {
5984       if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
5985         {
5986           _bfd_error_handler
5987             (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
5988
5989           bfd_set_error (bfd_error_bad_value);
5990           return FALSE;
5991         }
5992     }
5993
5994   /* When linking with V1.2 and V1.3 objects together the output is V1.2.
5995      and perf ext1 and DIV are mergerd to perf ext1.  */
5996   if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
5997     {
5998       elf_elfheader (obfd)->e_flags =
5999         (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6000         | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6001         | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6002            ?  E_NDS32_HAS_EXT_INST : 0)
6003         | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6004            ?  E_NDS32_HAS_EXT_INST : 0)
6005         | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6006         | ((in_version > out_version) ? out_version : in_version);
6007     }
6008   else
6009     {
6010       if (in_version != out_version)
6011         _bfd_error_handler
6012           /* xgettext:c-format */
6013           (_("%B: warning: Incompatible elf-versions %s and  %s."),
6014            ibfd, nds32_elfver_strtab[out_version],
6015            nds32_elfver_strtab[in_version]);
6016
6017       elf_elfheader (obfd)->e_flags = in_flags | out_flags
6018         | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6019         | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6020         | (in_version > out_version ?  out_version : in_version);
6021     }
6022
6023   return TRUE;
6024 }
6025
6026 /* Display the flags field.  */
6027
6028 static bfd_boolean
6029 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6030 {
6031   FILE *file = (FILE *) ptr;
6032
6033   BFD_ASSERT (abfd != NULL && ptr != NULL);
6034
6035   _bfd_elf_print_private_bfd_data (abfd, ptr);
6036
6037   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6038
6039   switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6040     {
6041     default:
6042     case E_N1_ARCH:
6043       fprintf (file, _(": n1 instructions"));
6044       break;
6045     case E_N1H_ARCH:
6046       fprintf (file, _(": n1h instructions"));
6047       break;
6048     }
6049
6050   fputc ('\n', file);
6051
6052   return TRUE;
6053 }
6054
6055 static unsigned int
6056 nds32_elf_action_discarded (asection *sec)
6057 {
6058
6059   if (strncmp
6060       (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6061     return 0;
6062
6063   return _bfd_elf_default_action_discarded (sec);
6064 }
6065
6066 static asection *
6067 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6068                         Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6069                         Elf_Internal_Sym *sym)
6070 {
6071   if (h != NULL)
6072     switch (ELF32_R_TYPE (rel->r_info))
6073       {
6074       case R_NDS32_GNU_VTINHERIT:
6075       case R_NDS32_GNU_VTENTRY:
6076       case R_NDS32_RELA_GNU_VTINHERIT:
6077       case R_NDS32_RELA_GNU_VTENTRY:
6078         return NULL;
6079       }
6080
6081   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6082 }
6083
6084 /* Look through the relocs for a section during the first phase.
6085    Since we don't do .gots or .plts, we just need to consider the
6086    virtual table relocs for gc.  */
6087
6088 static bfd_boolean
6089 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6090                         asection *sec, const Elf_Internal_Rela *relocs)
6091 {
6092   Elf_Internal_Shdr *symtab_hdr;
6093   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6094   const Elf_Internal_Rela *rel;
6095   const Elf_Internal_Rela *rel_end;
6096   struct elf_nds32_link_hash_table *htab;
6097   bfd *dynobj;
6098   asection *sreloc = NULL;
6099
6100   if (bfd_link_relocatable (info))
6101     return TRUE;
6102
6103   /* Don't do anything special with non-loaded, non-alloced sections.
6104      In particular, any relocs in such sections should not affect GOT
6105      and PLT reference counting (ie. we don't allow them to create GOT
6106      or PLT entries), there's no possibility or desire to optimize TLS
6107      relocs, and there's not much point in propagating relocs to shared
6108      libs that the dynamic linker won't relocate.  */
6109   if ((sec->flags & SEC_ALLOC) == 0)
6110     return TRUE;
6111
6112   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6113   sym_hashes = elf_sym_hashes (abfd);
6114   sym_hashes_end =
6115     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6116   if (!elf_bad_symtab (abfd))
6117     sym_hashes_end -= symtab_hdr->sh_info;
6118
6119   htab = nds32_elf_hash_table (info);
6120   dynobj = htab->root.dynobj;
6121
6122   rel_end = relocs + sec->reloc_count;
6123   for (rel = relocs; rel < rel_end; rel++)
6124     {
6125       enum elf_nds32_reloc_type r_type;
6126       struct elf_link_hash_entry *h;
6127       unsigned long r_symndx;
6128       int tls_type, old_tls_type;
6129
6130       r_symndx = ELF32_R_SYM (rel->r_info);
6131       r_type = ELF32_R_TYPE (rel->r_info);
6132       if (r_symndx < symtab_hdr->sh_info)
6133         h = NULL;
6134       else
6135         {
6136           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6137           while (h->root.type == bfd_link_hash_indirect
6138                  || h->root.type == bfd_link_hash_warning)
6139             h = (struct elf_link_hash_entry *) h->root.u.i.link;
6140         }
6141
6142       /* Some relocs require a global offset table.  We create
6143          got section here, since these relocation need got section
6144          and it is not created yet.  */
6145       if (htab->root.sgot == NULL)
6146         {
6147           switch (r_type)
6148             {
6149             case R_NDS32_GOT_HI20:
6150             case R_NDS32_GOT_LO12:
6151             case R_NDS32_GOT_LO15:
6152             case R_NDS32_GOT_LO19:
6153             case R_NDS32_GOT17S2_RELA:
6154             case R_NDS32_GOT15S2_RELA:
6155             case R_NDS32_GOTOFF:
6156             case R_NDS32_GOTOFF_HI20:
6157             case R_NDS32_GOTOFF_LO12:
6158             case R_NDS32_GOTOFF_LO15:
6159             case R_NDS32_GOTOFF_LO19:
6160             case R_NDS32_GOTPC20:
6161             case R_NDS32_GOTPC_HI20:
6162             case R_NDS32_GOTPC_LO12:
6163             case R_NDS32_GOT20:
6164             case R_NDS32_TLS_IE_HI20:
6165             case R_NDS32_TLS_IE_LO12S2:
6166               if (dynobj == NULL)
6167                 htab->root.dynobj = dynobj = abfd;
6168               if (!_bfd_elf_create_got_section (dynobj, info))
6169                 return FALSE;
6170               break;
6171
6172             default:
6173               break;
6174             }
6175         }
6176
6177       switch ((int) r_type)
6178         {
6179         case R_NDS32_GOT_HI20:
6180         case R_NDS32_GOT_LO12:
6181         case R_NDS32_GOT_LO15:
6182         case R_NDS32_GOT_LO19:
6183         case R_NDS32_GOT20:
6184         case R_NDS32_TLS_IE_HI20:
6185         case R_NDS32_TLS_IE_LO12S2:
6186           switch (r_type)
6187             {
6188             case R_NDS32_TLS_IE_HI20:
6189             case R_NDS32_TLS_IE_LO12S2:
6190               tls_type = GOT_TLS_IE;
6191               break;
6192             default:
6193               tls_type = GOT_NORMAL;
6194               break;
6195             }
6196           if (h != NULL)
6197             {
6198               old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6199               h->got.refcount += 1;
6200             }
6201           else
6202             {
6203               bfd_signed_vma *local_got_refcounts;
6204
6205               /* This is a global offset table entry for a local
6206                  symbol.  */
6207               local_got_refcounts = elf_local_got_refcounts (abfd);
6208               if (local_got_refcounts == NULL)
6209                 {
6210                   bfd_size_type size;
6211
6212                   size = symtab_hdr->sh_info;
6213                   size *= sizeof (bfd_signed_vma);
6214                   local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6215                   if (local_got_refcounts == NULL)
6216                     return FALSE;
6217                   elf_local_got_refcounts (abfd) = local_got_refcounts;
6218                 }
6219               local_got_refcounts[r_symndx] += 1;
6220               old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6221             }
6222
6223           /* We will already have issued an error message if there
6224              is a TLS/non-TLS mismatch, based on the symbol
6225              type.  So just combine any TLS types needed.  */
6226           if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6227               && tls_type != GOT_NORMAL)
6228             tls_type |= old_tls_type;
6229
6230           if (old_tls_type != tls_type)
6231             {
6232               if (h != NULL)
6233                 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6234               else
6235                 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6236             }
6237           break;
6238         case R_NDS32_9_PLTREL:
6239         case R_NDS32_25_PLTREL:
6240         case R_NDS32_PLTREL_HI20:
6241         case R_NDS32_PLTREL_LO12:
6242         case R_NDS32_PLT_GOTREL_HI20:
6243         case R_NDS32_PLT_GOTREL_LO12:
6244         case R_NDS32_PLT_GOTREL_LO15:
6245         case R_NDS32_PLT_GOTREL_LO19:
6246         case R_NDS32_PLT_GOTREL_LO20:
6247
6248           /* This symbol requires a procedure linkage table entry.  We
6249              actually build the entry in adjust_dynamic_symbol,
6250              because this might be a case of linking PIC code without
6251              linking in any dynamic objects, in which case we don't
6252              need to generate a procedure linkage table after all.  */
6253
6254           /* If this is a local symbol, we resolve it directly without
6255              creating a procedure linkage table entry.  */
6256           if (h == NULL)
6257             continue;
6258
6259           if (h->forced_local)
6260             break;
6261
6262           elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6263           h->needs_plt = 1;
6264           h->plt.refcount += 1;
6265           break;
6266
6267         case R_NDS32_16_RELA:
6268         case R_NDS32_20_RELA:
6269         case R_NDS32_5_RELA:
6270         case R_NDS32_32_RELA:
6271         case R_NDS32_HI20_RELA:
6272         case R_NDS32_LO12S3_RELA:
6273         case R_NDS32_LO12S2_RELA:
6274         case R_NDS32_LO12S2_DP_RELA:
6275         case R_NDS32_LO12S2_SP_RELA:
6276         case R_NDS32_LO12S1_RELA:
6277         case R_NDS32_LO12S0_RELA:
6278         case R_NDS32_LO12S0_ORI_RELA:
6279         case R_NDS32_SDA16S3_RELA:
6280         case R_NDS32_SDA17S2_RELA:
6281         case R_NDS32_SDA18S1_RELA:
6282         case R_NDS32_SDA19S0_RELA:
6283         case R_NDS32_SDA15S3_RELA:
6284         case R_NDS32_SDA15S2_RELA:
6285         case R_NDS32_SDA12S2_DP_RELA:
6286         case R_NDS32_SDA12S2_SP_RELA:
6287         case R_NDS32_SDA15S1_RELA:
6288         case R_NDS32_SDA15S0_RELA:
6289         case R_NDS32_SDA_FP7U2_RELA:
6290         case R_NDS32_15_PCREL_RELA:
6291         case R_NDS32_17_PCREL_RELA:
6292         case R_NDS32_25_PCREL_RELA:
6293
6294           if (h != NULL && !bfd_link_pic (info))
6295             {
6296               h->non_got_ref = 1;
6297               h->plt.refcount += 1;
6298             }
6299
6300           /* If we are creating a shared library, and this is a reloc against
6301              a global symbol, or a non PC relative reloc against a local
6302              symbol, then we need to copy the reloc into the shared library.
6303              However, if we are linking with -Bsymbolic, we do not need to
6304              copy a reloc against a global symbol which is defined in an
6305              object we are including in the link (i.e., DEF_REGULAR is set).
6306              At this point we have not seen all the input files, so it is
6307              possible that DEF_REGULAR is not set now but will be set later
6308              (it is never cleared).  We account for that possibility below by
6309              storing information in the dyn_relocs field of the hash table
6310              entry.  A similar situation occurs when creating shared libraries
6311              and symbol visibility changes render the symbol local.
6312
6313              If on the other hand, we are creating an executable, we may need
6314              to keep relocations for symbols satisfied by a dynamic library
6315              if we manage to avoid copy relocs for the symbol.  */
6316           if ((bfd_link_pic (info)
6317                && (sec->flags & SEC_ALLOC) != 0
6318                && ((r_type != R_NDS32_25_PCREL_RELA
6319                     && r_type != R_NDS32_15_PCREL_RELA
6320                     && r_type != R_NDS32_17_PCREL_RELA
6321                     && !(r_type == R_NDS32_32_RELA
6322                          && strcmp (sec->name, ".eh_frame") == 0))
6323                    || (h != NULL
6324                        && (!info->symbolic
6325                            || h->root.type == bfd_link_hash_defweak
6326                            || !h->def_regular))))
6327               || (!bfd_link_pic (info)
6328                   && (sec->flags & SEC_ALLOC) != 0
6329                   && h != NULL
6330                   && (h->root.type == bfd_link_hash_defweak
6331                       || !h->def_regular)))
6332             {
6333               struct elf_dyn_relocs *p;
6334               struct elf_dyn_relocs **head;
6335
6336               if (dynobj == NULL)
6337                 htab->root.dynobj = dynobj = abfd;
6338
6339               /* When creating a shared object, we must copy these
6340                  relocs into the output file.  We create a reloc
6341                  section in dynobj and make room for the reloc.  */
6342               if (sreloc == NULL)
6343                 {
6344                   const char *name;
6345
6346                   name = bfd_elf_string_from_elf_section
6347                     (abfd, elf_elfheader (abfd)->e_shstrndx,
6348                      elf_section_data (sec)->rela.hdr->sh_name);
6349                   if (name == NULL)
6350                     return FALSE;
6351
6352                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6353                               && strcmp (bfd_get_section_name (abfd, sec),
6354                                          name + 5) == 0);
6355
6356                   sreloc = bfd_get_section_by_name (dynobj, name);
6357                   if (sreloc == NULL)
6358                     {
6359                       flagword flags;
6360
6361                       sreloc = bfd_make_section (dynobj, name);
6362                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6363                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6364                       if ((sec->flags & SEC_ALLOC) != 0)
6365                         flags |= SEC_ALLOC | SEC_LOAD;
6366                       if (sreloc == NULL
6367                           || !bfd_set_section_flags (dynobj, sreloc, flags)
6368                           || !bfd_set_section_alignment (dynobj, sreloc, 2))
6369                         return FALSE;
6370
6371                       elf_section_type (sreloc) = SHT_RELA;
6372                     }
6373                   elf_section_data (sec)->sreloc = sreloc;
6374                 }
6375
6376               /* If this is a global symbol, we count the number of
6377                  relocations we need for this symbol.  */
6378               if (h != NULL)
6379                 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6380               else
6381                 {
6382                   asection *s;
6383                   void *vpp;
6384
6385                   Elf_Internal_Sym *isym;
6386                   isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6387                   if (isym == NULL)
6388                     return FALSE;
6389
6390                   /* Track dynamic relocs needed for local syms too.  */
6391                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6392                   if (s == NULL)
6393                     return FALSE;
6394
6395                   vpp = &elf_section_data (s)->local_dynrel;
6396                   head = (struct elf_dyn_relocs **) vpp;
6397                 }
6398
6399               p = *head;
6400               if (p == NULL || p->sec != sec)
6401                 {
6402                   bfd_size_type amt = sizeof (*p);
6403                   p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
6404                   if (p == NULL)
6405                     return FALSE;
6406                   p->next = *head;
6407                   *head = p;
6408                   p->sec = sec;
6409                   p->count = 0;
6410                   p->pc_count = 0;
6411                 }
6412
6413               p->count += 1;
6414               if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6415                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6416                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6417                 p->pc_count += 1;
6418             }
6419           break;
6420
6421           /* This relocation describes the C++ object vtable hierarchy.
6422              Reconstruct it for later use during GC.  */
6423         case R_NDS32_RELA_GNU_VTINHERIT:
6424         case R_NDS32_GNU_VTINHERIT:
6425           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6426             return FALSE;
6427           break;
6428
6429           /* This relocation describes which C++ vtable entries are actually
6430              used.  Record for later use during GC.  */
6431         case R_NDS32_GNU_VTENTRY:
6432           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6433             return FALSE;
6434           break;
6435         case R_NDS32_RELA_GNU_VTENTRY:
6436           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6437             return FALSE;
6438           break;
6439         }
6440     }
6441
6442   return TRUE;
6443 }
6444
6445 /* Write VAL in uleb128 format to P, returning a pointer to the
6446    following byte.
6447    This code is copied from elf-attr.c.  */
6448
6449 static bfd_byte *
6450 write_uleb128 (bfd_byte *p, unsigned int val)
6451 {
6452   bfd_byte c;
6453   do
6454     {
6455       c = val & 0x7f;
6456       val >>= 7;
6457       if (val)
6458         c |= 0x80;
6459       *(p++) = c;
6460     }
6461   while (val);
6462   return p;
6463 }
6464
6465 static bfd_signed_vma
6466 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6467                   Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6468                   int *pic_ext_target)
6469 {
6470   bfd_signed_vma foff;
6471   bfd_vma symval, addend;
6472   asection *sym_sec;
6473
6474   /* Get the value of the symbol referred to by the reloc.  */
6475   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6476     {
6477       Elf_Internal_Sym *isym;
6478
6479       /* A local symbol.  */
6480       isym = isymbuf + ELF32_R_SYM (irel->r_info);
6481
6482       if (isym->st_shndx == SHN_UNDEF)
6483         sym_sec = bfd_und_section_ptr;
6484       else if (isym->st_shndx == SHN_ABS)
6485         sym_sec = bfd_abs_section_ptr;
6486       else if (isym->st_shndx == SHN_COMMON)
6487         sym_sec = bfd_com_section_ptr;
6488       else
6489         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6490       symval = isym->st_value + sym_sec->output_section->vma
6491                + sym_sec->output_offset;
6492     }
6493   else
6494     {
6495       unsigned long indx;
6496       struct elf_link_hash_entry *h;
6497       bfd *owner;
6498
6499       /* An external symbol.  */
6500       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6501       h = elf_sym_hashes (abfd)[indx];
6502       BFD_ASSERT (h != NULL);
6503
6504       if (h->root.type != bfd_link_hash_defined
6505           && h->root.type != bfd_link_hash_defweak)
6506         /* This appears to be a reference to an undefined
6507            symbol.  Just ignore it--it will be caught by the
6508            regular reloc processing.  */
6509         return 0;
6510       owner = h->root.u.def.section->owner;
6511       if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6512         *pic_ext_target = 1;
6513
6514       if (h->root.u.def.section->flags & SEC_MERGE)
6515         {
6516           sym_sec = h->root.u.def.section;
6517           symval = _bfd_merged_section_offset (abfd, &sym_sec,
6518                                                elf_section_data (sym_sec)->sec_info,
6519                                                h->root.u.def.value);
6520           symval = symval + sym_sec->output_section->vma
6521                    + sym_sec->output_offset;
6522         }
6523       else
6524         symval = (h->root.u.def.value
6525                   + h->root.u.def.section->output_section->vma
6526                   + h->root.u.def.section->output_offset);
6527     }
6528
6529   addend = irel->r_addend;
6530
6531   foff = (symval + addend
6532           - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6533   return foff;
6534 }
6535
6536 static bfd_vma
6537 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6538                               Elf_Internal_Sym *isymbuf,
6539                               Elf_Internal_Rela *irel,
6540                               Elf_Internal_Shdr *symtab_hdr)
6541 {
6542   bfd_vma symval;
6543
6544   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6545     {
6546       Elf_Internal_Sym *isym;
6547       asection *sym_sec;
6548       /* A local symbol.  */
6549       isym = isymbuf + ELF32_R_SYM (irel->r_info);
6550
6551       if (isym->st_shndx == SHN_UNDEF)
6552         sym_sec = bfd_und_section_ptr;
6553       else if (isym->st_shndx == SHN_ABS)
6554         sym_sec = bfd_abs_section_ptr;
6555       else if (isym->st_shndx == SHN_COMMON)
6556         sym_sec = bfd_com_section_ptr;
6557       else
6558         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6559       symval = isym->st_value + sym_sec->output_section->vma
6560                + sym_sec->output_offset;
6561     }
6562   else
6563     {
6564       unsigned long indx;
6565       struct elf_link_hash_entry *h;
6566       struct elf_nds32_link_hash_table *htab;
6567       asection *splt;
6568
6569       /* An external symbol.  */
6570       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6571       h = elf_sym_hashes (abfd)[indx];
6572       BFD_ASSERT (h != NULL);
6573       htab = nds32_elf_hash_table (link_info);
6574       splt = htab->root.splt;
6575
6576       while (h->root.type == bfd_link_hash_indirect
6577              || h->root.type == bfd_link_hash_warning)
6578         h = (struct elf_link_hash_entry *) h->root.u.i.link;
6579
6580       if (h->plt.offset == (bfd_vma) - 1)
6581         {
6582           if (h->root.type != bfd_link_hash_defined
6583               && h->root.type != bfd_link_hash_defweak)
6584             /* This appears to be a reference to an undefined
6585              * symbol.  Just ignore it--it will be caught by the
6586              * regular reloc processing.  */
6587             return 0;
6588           symval = (h->root.u.def.value
6589                     + h->root.u.def.section->output_section->vma
6590                     + h->root.u.def.section->output_offset);
6591         }
6592       else
6593         symval = splt->output_section->vma + h->plt.offset;
6594     }
6595
6596   return symval;
6597 }
6598
6599 static bfd_signed_vma
6600 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6601                       Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6602                       Elf_Internal_Shdr *symtab_hdr)
6603 {
6604   bfd_vma foff;
6605   if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6606                                             symtab_hdr)) == 0)
6607     return 0;
6608   else
6609     return foff - (irel->r_offset
6610                    + sec->output_section->vma + sec->output_offset);
6611 }
6612 \f
6613 /* Convert a 32-bit instruction to 16-bit one.
6614    INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6615    instruction.  If INSN_TYPE is not NULL, it the CGEN instruction
6616    type of INSN16.  Return 1 if successful.  */
6617
6618 static int
6619 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6620                              int *pinsn_type)
6621 {
6622   uint16_t insn16 = 0;
6623   int insn_type = 0;
6624   unsigned long mach = bfd_get_mach (abfd);
6625
6626   if (N32_SH5 (insn) != 0)
6627     return 0;
6628
6629   switch (N32_SUB5 (insn))
6630     {
6631     case N32_ALU1_ADD_SLLI:
6632     case N32_ALU1_ADD_SRLI:
6633       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6634         {
6635           insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6636                                 N32_RB5 (insn));
6637           insn_type = NDS32_INSN_ADD333;
6638         }
6639       else if (N32_IS_RT4 (insn))
6640         {
6641           if (N32_RT5 (insn) == N32_RA5 (insn))
6642             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6643           else if (N32_RT5 (insn) == N32_RB5 (insn))
6644             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6645           insn_type = NDS32_INSN_ADD45;
6646         }
6647       break;
6648
6649     case N32_ALU1_SUB_SLLI:
6650     case N32_ALU1_SUB_SRLI:
6651       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6652         {
6653           insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6654                                 N32_RB5 (insn));
6655           insn_type = NDS32_INSN_SUB333;
6656         }
6657       else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6658         {
6659           insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6660           insn_type = NDS32_INSN_SUB45;
6661         }
6662       break;
6663
6664     case N32_ALU1_AND_SLLI:
6665     case N32_ALU1_AND_SRLI:
6666       /* and $rt, $rt, $rb -> and33 for v3, v3m.  */
6667       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6668           && N32_IS_RB3 (insn))
6669         {
6670           if (N32_RT5 (insn) == N32_RA5 (insn))
6671             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6672           else if (N32_RT5 (insn) == N32_RB5 (insn))
6673             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6674           if (insn16)
6675             insn_type = NDS32_INSN_AND33;
6676         }
6677       break;
6678
6679     case N32_ALU1_XOR_SLLI:
6680     case N32_ALU1_XOR_SRLI:
6681       /* xor $rt, $rt, $rb -> xor33 for v3, v3m.  */
6682       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6683           && N32_IS_RB3 (insn))
6684         {
6685           if (N32_RT5 (insn) == N32_RA5 (insn))
6686             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6687           else if (N32_RT5 (insn) == N32_RB5 (insn))
6688             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6689           if (insn16)
6690             insn_type = NDS32_INSN_XOR33;
6691         }
6692       break;
6693
6694     case N32_ALU1_OR_SLLI:
6695     case N32_ALU1_OR_SRLI:
6696       /* or $rt, $rt, $rb -> or33 for v3, v3m.  */
6697       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6698           && N32_IS_RB3 (insn))
6699         {
6700           if (N32_RT5 (insn) == N32_RA5 (insn))
6701             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6702           else if (N32_RT5 (insn) == N32_RB5 (insn))
6703             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6704           if (insn16)
6705             insn_type = NDS32_INSN_OR33;
6706         }
6707       break;
6708     case N32_ALU1_NOR:
6709       /* nor $rt, $ra, $ra -> not33 for v3, v3m.  */
6710       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6711           && N32_RA5 (insn) == N32_RB5 (insn))
6712         {
6713           insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6714           insn_type = NDS32_INSN_NOT33;
6715         }
6716       break;
6717     case N32_ALU1_SRAI:
6718       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6719         {
6720           insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6721           insn_type = NDS32_INSN_SRAI45;
6722         }
6723       break;
6724
6725     case N32_ALU1_SRLI:
6726       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6727         {
6728           insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6729           insn_type = NDS32_INSN_SRLI45;
6730         }
6731       break;
6732
6733     case N32_ALU1_SLLI:
6734       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6735         {
6736           insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6737                                 N32_UB5 (insn));
6738           insn_type = NDS32_INSN_SLLI333;
6739         }
6740       break;
6741
6742     case N32_ALU1_ZEH:
6743       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6744         {
6745           insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6746           insn_type = NDS32_INSN_ZEH33;
6747         }
6748       break;
6749
6750     case N32_ALU1_SEB:
6751       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6752         {
6753           insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
6754           insn_type = NDS32_INSN_SEB33;
6755         }
6756       break;
6757
6758     case N32_ALU1_SEH:
6759       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6760         {
6761           insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
6762           insn_type = NDS32_INSN_SEH33;
6763         }
6764       break;
6765
6766     case N32_ALU1_SLT:
6767       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
6768         {
6769           /* Implicit r15.  */
6770           insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
6771           insn_type = NDS32_INSN_SLT45;
6772         }
6773       break;
6774
6775     case N32_ALU1_SLTS:
6776       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
6777         {
6778           /* Implicit r15.  */
6779           insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
6780           insn_type = NDS32_INSN_SLTS45;
6781         }
6782       break;
6783     }
6784
6785   if ((insn16 & 0x8000) == 0)
6786     return 0;
6787
6788   if (pinsn16)
6789     *pinsn16 = insn16;
6790   if (pinsn_type)
6791     *pinsn_type = insn_type;
6792   return 1;
6793 }
6794
6795 static int
6796 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6797                              int *pinsn_type)
6798 {
6799   uint16_t insn16 = 0;
6800   int insn_type;
6801   unsigned long mach = bfd_get_mach (abfd);
6802
6803   /* TODO: bset, bclr, btgl, btst.  */
6804   if (__GF (insn, 6, 4) != 0)
6805     return 0;
6806
6807   switch (N32_IMMU (insn, 6))
6808     {
6809     case N32_ALU2_MUL:
6810       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6811           && N32_IS_RB3 (insn))
6812         {
6813           if (N32_RT5 (insn) == N32_RA5 (insn))
6814             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
6815           else if (N32_RT5 (insn) == N32_RB5 (insn))
6816             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
6817           if (insn16)
6818             insn_type = NDS32_INSN_MUL33;
6819         }
6820     }
6821
6822   if ((insn16 & 0x8000) == 0)
6823     return 0;
6824
6825   if (pinsn16)
6826     *pinsn16 = insn16;
6827   if (pinsn_type)
6828     *pinsn_type = insn_type;
6829   return 1;
6830 }
6831
6832 int
6833 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6834                         int *pinsn_type)
6835 {
6836   int op6;
6837   uint16_t insn16 = 0;
6838   int insn_type;
6839   unsigned long mach = bfd_get_mach (abfd);
6840
6841   /* Decode 32-bit instruction.  */
6842   if (insn & 0x80000000)
6843     {
6844       /* Not 32-bit insn.  */
6845       return 0;
6846     }
6847
6848   op6 = N32_OP6 (insn);
6849
6850   /* Convert it to 16-bit instruction.  */
6851   switch (op6)
6852     {
6853     case N32_OP6_MOVI:
6854       if (IS_WITHIN_S (N32_IMM20S (insn), 5))
6855         {
6856           insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
6857           insn_type = NDS32_INSN_MOVI55;
6858         }
6859       else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
6860                && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
6861         {
6862           insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
6863                                N32_IMM20S (insn) - 16);
6864           insn_type = NDS32_INSN_MOVPI45;
6865         }
6866       break;
6867
6868     case N32_OP6_ADDI:
6869       if (N32_IMM15S (insn) == 0)
6870         {
6871           /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
6872              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
6873           if (mach <= MACH_V2
6874               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
6875             {
6876               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
6877               insn_type = NDS32_INSN_MOV55;
6878             }
6879         }
6880       else if (N32_IMM15S (insn) > 0)
6881         {
6882           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
6883             {
6884               insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
6885                                     N32_IMM15S (insn));
6886               insn_type = NDS32_INSN_ADDI333;
6887             }
6888           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
6889                    && N32_IMM15S (insn) < 32)
6890             {
6891               insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
6892               insn_type = NDS32_INSN_ADDI45;
6893             }
6894           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
6895                    && N32_RT5 (insn) == N32_RA5 (insn)
6896                    && N32_IMM15S (insn) < 512)
6897             {
6898               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
6899               insn_type = NDS32_INSN_ADDI10_SP;
6900             }
6901           else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
6902                    && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
6903                    && (N32_IMM15S (insn) % 4 == 0))
6904             {
6905               insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
6906                                    N32_IMM15S (insn) >> 2);
6907               insn_type = NDS32_INSN_ADDRI36_SP;
6908             }
6909         }
6910       else
6911         {
6912           /* Less than 0.  */
6913           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
6914             {
6915               insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
6916                                     0 - N32_IMM15S (insn));
6917               insn_type = NDS32_INSN_SUBI333;
6918             }
6919           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
6920                    && N32_IMM15S (insn) > -32)
6921             {
6922               insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
6923                                    0 - N32_IMM15S (insn));
6924               insn_type = NDS32_INSN_SUBI45;
6925             }
6926           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
6927                    && N32_RT5 (insn) == N32_RA5 (insn)
6928                    && N32_IMM15S (insn) >= -512)
6929             {
6930               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
6931               insn_type = NDS32_INSN_ADDI10_SP;
6932             }
6933         }
6934       break;
6935
6936     case N32_OP6_ORI:
6937       if (N32_IMM15S (insn) == 0)
6938         {
6939           /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
6940              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
6941           if (mach <= MACH_V2
6942               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
6943             {
6944               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
6945               insn_type = NDS32_INSN_MOV55;
6946             }
6947         }
6948       break;
6949
6950     case N32_OP6_SUBRI:
6951       if (mach >= MACH_V3 && N32_IS_RT3 (insn)
6952           && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
6953         {
6954           insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
6955           insn_type = NDS32_INSN_NEG33;
6956         }
6957       break;
6958
6959     case N32_OP6_ANDI:
6960       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6961         {
6962           if (N32_IMM15U (insn) == 1)
6963             {
6964               insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
6965               insn_type = NDS32_INSN_XLSB33;
6966             }
6967           else if (N32_IMM15U (insn) == 0x7ff)
6968             {
6969               insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
6970               insn_type = NDS32_INSN_X11B33;
6971             }
6972           else if (N32_IMM15U (insn) == 0xff)
6973             {
6974               insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
6975               insn_type = NDS32_INSN_ZEB33;
6976             }
6977           else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
6978                    && N32_IMM15U (insn) < 256)
6979             {
6980               int imm15u = N32_IMM15U (insn);
6981
6982               if (__builtin_popcount (imm15u) == 1)
6983                 {
6984                   /* BMSKI33 */
6985                   int imm3u = __builtin_ctz (imm15u);
6986
6987                   insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
6988                   insn_type = NDS32_INSN_BMSKI33;
6989                 }
6990               else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
6991                 {
6992                   /* FEXTI33 */
6993                   int imm3u = __builtin_ctz (imm15u + 1) - 1;
6994
6995                   insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
6996                   insn_type = NDS32_INSN_FEXTI33;
6997                 }
6998             }
6999         }
7000       break;
7001
7002     case N32_OP6_SLTI:
7003       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7004           && IS_WITHIN_U (N32_IMM15S (insn), 5))
7005         {
7006           insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7007           insn_type = NDS32_INSN_SLTI45;
7008         }
7009       break;
7010
7011     case N32_OP6_SLTSI:
7012       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7013           && IS_WITHIN_U (N32_IMM15S (insn), 5))
7014         {
7015           insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7016           insn_type = NDS32_INSN_SLTSI45;
7017         }
7018       break;
7019
7020     case N32_OP6_LWI:
7021       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7022         {
7023           insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7024           insn_type = NDS32_INSN_LWI450;
7025         }
7026       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7027                && IS_WITHIN_U (N32_IMM15S (insn), 3))
7028         {
7029           insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7030                                 N32_IMM15S (insn));
7031           insn_type = NDS32_INSN_LWI333;
7032         }
7033       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7034                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7035         {
7036           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7037           insn_type = NDS32_INSN_LWI37;
7038         }
7039       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7040                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7041         {
7042           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7043           insn_type = NDS32_INSN_LWI37_SP;
7044         }
7045       else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7046                && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7047         {
7048           insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7049                                N32_IMM15S (insn) + 32);
7050           insn_type = NDS32_INSN_LWI45_FE;
7051         }
7052       break;
7053
7054     case N32_OP6_SWI:
7055       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7056         {
7057           insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7058           insn_type = NDS32_INSN_SWI450;
7059         }
7060       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7061                && IS_WITHIN_U (N32_IMM15S (insn), 3))
7062         {
7063           insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7064                                 N32_IMM15S (insn));
7065           insn_type = NDS32_INSN_SWI333;
7066         }
7067       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7068                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7069         {
7070           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7071           insn_type = NDS32_INSN_SWI37;
7072         }
7073       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7074                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7075         {
7076           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7077           insn_type = NDS32_INSN_SWI37_SP;
7078         }
7079       break;
7080
7081     case N32_OP6_LWI_BI:
7082       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7083           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7084         {
7085           insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7086                                 N32_IMM15S (insn));
7087           insn_type = NDS32_INSN_LWI333_BI;
7088         }
7089       break;
7090
7091     case N32_OP6_SWI_BI:
7092       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7093           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7094         {
7095           insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7096                                 N32_IMM15S (insn));
7097           insn_type = NDS32_INSN_SWI333_BI;
7098         }
7099       break;
7100
7101     case N32_OP6_LHI:
7102       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7103           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7104         {
7105           insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7106                                 N32_IMM15S (insn));
7107           insn_type = NDS32_INSN_LHI333;
7108         }
7109       break;
7110
7111     case N32_OP6_SHI:
7112       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7113           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7114         {
7115           insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7116                                 N32_IMM15S (insn));
7117           insn_type = NDS32_INSN_SHI333;
7118         }
7119       break;
7120
7121     case N32_OP6_LBI:
7122       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7123           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7124         {
7125           insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7126                                 N32_IMM15S (insn));
7127           insn_type = NDS32_INSN_LBI333;
7128         }
7129       break;
7130
7131     case N32_OP6_SBI:
7132       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7133           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7134         {
7135           insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7136                                 N32_IMM15S (insn));
7137           insn_type = NDS32_INSN_SBI333;
7138         }
7139       break;
7140
7141     case N32_OP6_ALU1:
7142       return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7143
7144     case N32_OP6_ALU2:
7145       return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7146
7147     case N32_OP6_BR1:
7148       if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7149         goto done;
7150
7151       if ((insn & N32_BIT (14)) == 0)
7152         {
7153           /* N32_BR1_BEQ */
7154           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7155               && N32_RT5 (insn) != REG_R5)
7156             insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7157           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7158                    && N32_RA5 (insn) != REG_R5)
7159             insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7160           insn_type = NDS32_INSN_BEQS38;
7161           break;
7162         }
7163       else
7164         {
7165           /* N32_BR1_BNE */
7166           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7167               && N32_RT5 (insn) != REG_R5)
7168             insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7169           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7170                    && N32_RA5 (insn) != REG_R5)
7171             insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7172           insn_type = NDS32_INSN_BNES38;
7173           break;
7174         }
7175       break;
7176
7177     case N32_OP6_BR2:
7178       switch (N32_BR2_SUB (insn))
7179         {
7180         case N32_BR2_BEQZ:
7181           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7182             {
7183               insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7184               insn_type = NDS32_INSN_BEQZ38;
7185             }
7186           else if (N32_RT5 (insn) == REG_R15
7187                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
7188             {
7189               insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7190               insn_type = NDS32_INSN_BEQZS8;
7191             }
7192           break;
7193
7194         case N32_BR2_BNEZ:
7195           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7196             {
7197               insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7198               insn_type = NDS32_INSN_BNEZ38;
7199             }
7200           else if (N32_RT5 (insn) == REG_R15
7201                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
7202             {
7203               insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7204               insn_type = NDS32_INSN_BNEZS8;
7205             }
7206           break;
7207
7208         case N32_BR2_IFCALL:
7209           if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7210             {
7211               insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7212               insn_type = NDS32_INSN_IFCALL9;
7213             }
7214           break;
7215         }
7216       break;
7217
7218     case N32_OP6_JI:
7219       if ((insn & N32_BIT (24)) == 0)
7220         {
7221           /* N32_JI_J */
7222           if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7223             {
7224               insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7225               insn_type = NDS32_INSN_J8;
7226             }
7227         }
7228       break;
7229
7230     case N32_OP6_JREG:
7231       if (__GF (insn, 8, 2) != 0)
7232         goto done;
7233
7234       switch (N32_IMMU (insn, 5))
7235         {
7236         case N32_JREG_JR:
7237           if (N32_JREG_HINT (insn) == 0)
7238             {
7239               /* jr */
7240               insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7241               insn_type = NDS32_INSN_JR5;
7242             }
7243           else if (N32_JREG_HINT (insn) == 1)
7244             {
7245               /* ret */
7246               insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7247               insn_type = NDS32_INSN_RET5;
7248             }
7249           else if (N32_JREG_HINT (insn) == 3)
7250             {
7251               /* ifret = mov55 $sp, $sp */
7252               insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7253               insn_type = NDS32_INSN_IFRET;
7254             }
7255           break;
7256
7257         case N32_JREG_JRAL:
7258           /* It's convertible when return rt5 is $lp and address
7259              translation is kept.  */
7260           if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7261             {
7262               insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7263               insn_type = NDS32_INSN_JRAL5;
7264             }
7265           break;
7266         }
7267       break;
7268
7269     case N32_OP6_MISC:
7270       if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7271         {
7272           /* For v3, swid above 31 are used for ex9.it.  */
7273           insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7274           insn_type = NDS32_INSN_BREAK16;
7275         }
7276       break;
7277
7278     default:
7279       /* This instruction has no 16-bit variant.  */
7280       goto done;
7281     }
7282
7283 done:
7284   /* Bit-15 of insn16 should be set for a valid instruction.  */
7285   if ((insn16 & 0x8000) == 0)
7286     return 0;
7287
7288   if (pinsn16)
7289     *pinsn16 = insn16;
7290   if (pinsn_type)
7291     *pinsn_type = insn_type;
7292   return 1;
7293 }
7294
7295 static int
7296 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7297                           Elf_Internal_Rela *reloc)
7298 {
7299   uint16_t insn16 = 0;
7300
7301   if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7302       || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7303     return 0;
7304
7305   if (!N32_IS_RT3 (insn))
7306     return 0;
7307
7308   switch (N32_OP6 (insn))
7309     {
7310     case N32_OP6_LWI:
7311       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7312         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7313       break;
7314     case N32_OP6_SWI:
7315       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7316         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7317       break;
7318     case N32_OP6_HWGP:
7319       if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7320         break;
7321
7322       if (__GF (insn, 17, 3) == 6)
7323         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7324       else if (__GF (insn, 17, 3) == 7)
7325         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7326       break;
7327     }
7328
7329   if ((insn16 & 0x8000) == 0)
7330     return 0;
7331
7332   *pinsn16 = insn16;
7333   return 1;
7334 }
7335
7336 /* Convert a 16-bit instruction to 32-bit one.
7337    INSN16 it the input and PINSN it the point to output.
7338    Return non-zero on successful.  Otherwise 0 is returned.  */
7339
7340 int
7341 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7342 {
7343   uint32_t insn = 0xffffffff;
7344   unsigned long mach = bfd_get_mach (abfd);
7345
7346   /* NOTE: push25, pop25 and movd44 do not have 32-bit variants.  */
7347
7348   switch (__GF (insn16, 9, 6))
7349     {
7350     case 0x4:                   /* add45 */
7351       insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7352                        N16_RA5 (insn16));
7353       goto done;
7354     case 0x5:                   /* sub45 */
7355       insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7356                        N16_RA5 (insn16));
7357       goto done;
7358     case 0x6:                   /* addi45 */
7359       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7360                         N16_IMM5U (insn16));
7361       goto done;
7362     case 0x7:                   /* subi45 */
7363       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7364                         -N16_IMM5U (insn16));
7365       goto done;
7366     case 0x8:                   /* srai45 */
7367       insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7368                        N16_IMM5U (insn16));
7369       goto done;
7370     case 0x9:                   /* srli45 */
7371       insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7372                        N16_IMM5U (insn16));
7373       goto done;
7374     case 0xa:                   /* slli333 */
7375       insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7376                        N16_IMM3U (insn16));
7377       goto done;
7378     case 0xc:                   /* add333 */
7379       insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7380                        N16_RB3 (insn16));
7381       goto done;
7382     case 0xd:                   /* sub333 */
7383       insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7384                        N16_RB3 (insn16));
7385       goto done;
7386     case 0xe:                   /* addi333 */
7387       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7388                         N16_IMM3U (insn16));
7389       goto done;
7390     case 0xf:                   /* subi333 */
7391       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7392                         -N16_IMM3U (insn16));
7393       goto done;
7394     case 0x10:                  /* lwi333 */
7395       insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7396                         N16_IMM3U (insn16));
7397       goto done;
7398     case 0x12:                  /* lhi333 */
7399       insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7400                         N16_IMM3U (insn16));
7401       goto done;
7402     case 0x13:                  /* lbi333 */
7403       insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7404                         N16_IMM3U (insn16));
7405       goto done;
7406     case 0x11:                  /* lwi333.bi */
7407       insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7408                         N16_IMM3U (insn16));
7409       goto done;
7410     case 0x14:                  /* swi333 */
7411       insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7412                         N16_IMM3U (insn16));
7413       goto done;
7414     case 0x16:                  /* shi333 */
7415       insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7416                         N16_IMM3U (insn16));
7417       goto done;
7418     case 0x17:                  /* sbi333 */
7419       insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7420                         N16_IMM3U (insn16));
7421       goto done;
7422     case 0x15:                  /* swi333.bi */
7423       insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7424                         N16_IMM3U (insn16));
7425       goto done;
7426     case 0x18:                  /* addri36.sp */
7427       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7428                         N16_IMM6U (insn16) << 2);
7429       goto done;
7430     case 0x19:                  /* lwi45.fe */
7431       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7432                         (N16_IMM5U (insn16) - 32));
7433       goto done;
7434     case 0x1a:                  /* lwi450 */
7435       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7436       goto done;
7437     case 0x1b:                  /* swi450 */
7438       insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7439       goto done;
7440
7441       /* These are r15 implied instructions.  */
7442     case 0x30:                  /* slts45 */
7443       insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7444       goto done;
7445     case 0x31:                  /* slt45 */
7446       insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7447       goto done;
7448     case 0x32:                  /* sltsi45 */
7449       insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7450       goto done;
7451     case 0x33:                  /* slti45 */
7452       insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7453       goto done;
7454     case 0x34:                  /* beqzs8, bnezs8 */
7455       if (insn16 & N32_BIT (8))
7456         insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7457       else
7458         insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7459       goto done;
7460
7461     case 0x35:                  /* break16, ex9.it */
7462       /* Only consider range of v3 break16.  */
7463       insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7464       goto done;
7465
7466     case 0x3c:                  /* ifcall9 */
7467       insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7468       goto done;
7469     case 0x3d:                  /* movpi45 */
7470       insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7471       goto done;
7472
7473     case 0x3f:                  /* MISC33 */
7474       switch (insn16 & 0x7)
7475         {
7476         case 2:                 /* neg33 */
7477           insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7478           break;
7479         case 3:                 /* not33 */
7480           insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7481                            N16_RA3 (insn16));
7482           break;
7483         case 4:                 /* mul33 */
7484           insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7485                            N16_RA3 (insn16));
7486           break;
7487         case 5:                 /* xor33 */
7488           insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7489                            N16_RA3 (insn16));
7490           break;
7491         case 6:                 /* and33 */
7492           insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7493                            N16_RA3 (insn16));
7494           break;
7495         case 7:                 /* or33 */
7496           insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7497                            N16_RA3 (insn16));
7498           break;
7499         }
7500       goto done;
7501
7502     case 0xb:
7503       switch (insn16 & 0x7)
7504         {
7505         case 0:                 /* zeb33 */
7506           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7507           break;
7508         case 1:                 /* zeh33 */
7509           insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7510           break;
7511         case 2:                 /* seb33 */
7512           insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7513           break;
7514         case 3:                 /* seh33 */
7515           insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7516           break;
7517         case 4:                 /* xlsb33 */
7518           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7519           break;
7520         case 5:                 /* x11b33 */
7521           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7522           break;
7523         case 6:                 /* bmski33 */
7524           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7525                             1 << __GF (insn16, 3, 3));
7526           break;
7527         case 7:                 /* fexti33 */
7528           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7529                             (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7530           break;
7531         }
7532       goto done;
7533     }
7534
7535   switch (__GF (insn16, 10, 5))
7536     {
7537     case 0x0:                   /* mov55 or ifret16 */
7538       if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7539           && N16_RT5 (insn16) == N16_RA5 (insn16))
7540         insn = N32_JREG (JR, 0, 0, 0, 3);
7541       else
7542         insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7543       goto done;
7544     case 0x1:                   /* movi55 */
7545       insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7546       goto done;
7547     case 0x1b:                  /* addi10s (V2) */
7548       insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7549       goto done;
7550     }
7551
7552   switch (__GF (insn16, 11, 4))
7553     {
7554     case 0x7:                   /* lwi37.fp/swi37.fp */
7555       if (insn16 & N32_BIT (7)) /* swi37.fp */
7556         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7557       else                      /* lwi37.fp */
7558         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7559       goto done;
7560     case 0x8:                   /* beqz38 */
7561       insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7562       goto done;
7563     case 0x9:                   /* bnez38 */
7564       insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7565       goto done;
7566     case 0xa:                   /* beqs38/j8, implied r5 */
7567       if (N16_RT38 (insn16) == 5)
7568         insn = N32_JI (J, N16_IMM8S (insn16));
7569       else
7570         insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7571       goto done;
7572     case 0xb:                   /* bnes38 and others */
7573       if (N16_RT38 (insn16) == 5)
7574         {
7575           switch (__GF (insn16, 5, 3))
7576             {
7577             case 0:             /* jr5 */
7578               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7579               break;
7580             case 4:             /* ret5 */
7581               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7582               break;
7583             case 1:             /* jral5 */
7584               insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7585               break;
7586             case 2:             /* ex9.it imm5 */
7587               /* ex9.it had no 32-bit variantl.  */
7588               break;
7589             case 5:             /* add5.pc */
7590               /* add5.pc had no 32-bit variantl.  */
7591               break;
7592             }
7593         }
7594       else                      /* bnes38 */
7595         insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7596       goto done;
7597     case 0xe:                   /* lwi37/swi37 */
7598       if (insn16 & (1 << 7))    /* swi37.sp */
7599         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7600       else                      /* lwi37.sp */
7601         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7602       goto done;
7603     }
7604
7605 done:
7606   if (insn & 0x80000000)
7607     return 0;
7608
7609   if (pinsn)
7610     *pinsn = insn;
7611   return 1;
7612 }
7613 \f
7614 static bfd_boolean
7615 is_sda_access_insn (unsigned long insn)
7616 {
7617   switch (N32_OP6 (insn))
7618     {
7619     case N32_OP6_LWI:
7620     case N32_OP6_LHI:
7621     case N32_OP6_LHSI:
7622     case N32_OP6_LBI:
7623     case N32_OP6_LBSI:
7624     case N32_OP6_SWI:
7625     case N32_OP6_SHI:
7626     case N32_OP6_SBI:
7627     case N32_OP6_LWC:
7628     case N32_OP6_LDC:
7629     case N32_OP6_SWC:
7630     case N32_OP6_SDC:
7631       return TRUE;
7632     default:
7633       ;
7634     }
7635   return FALSE;
7636 }
7637
7638 static unsigned long
7639 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7640 {
7641   uint32_t oinsn = 0;
7642
7643   switch (type)
7644     {
7645     case R_NDS32_GOT_LO12:
7646     case R_NDS32_GOTOFF_LO12:
7647     case R_NDS32_PLTREL_LO12:
7648     case R_NDS32_PLT_GOTREL_LO12:
7649     case R_NDS32_LO12S0_RELA:
7650       switch (N32_OP6 (insn))
7651         {
7652         case N32_OP6_LBI:
7653           /* lbi.gp */
7654           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7655           break;
7656         case N32_OP6_LBSI:
7657           /* lbsi.gp */
7658           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
7659           break;
7660         case N32_OP6_SBI:
7661           /* sbi.gp */
7662           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7663           break;
7664         case N32_OP6_ORI:
7665           /* addi.gp */
7666           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
7667           break;
7668         }
7669       break;
7670
7671     case R_NDS32_LO12S1_RELA:
7672       switch (N32_OP6 (insn))
7673         {
7674         case N32_OP6_LHI:
7675           /* lhi.gp */
7676           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7677           break;
7678         case N32_OP6_LHSI:
7679           /* lhsi.gp */
7680           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
7681           break;
7682         case N32_OP6_SHI:
7683           /* shi.gp */
7684           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
7685           break;
7686         }
7687       break;
7688
7689     case R_NDS32_LO12S2_RELA:
7690       switch (N32_OP6 (insn))
7691         {
7692         case N32_OP6_LWI:
7693           /* lwi.gp */
7694           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7695           break;
7696         case N32_OP6_SWI:
7697           /* swi.gp */
7698           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7699           break;
7700         }
7701       break;
7702
7703     case R_NDS32_LO12S2_DP_RELA:
7704     case R_NDS32_LO12S2_SP_RELA:
7705       oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7706       break;
7707     }
7708
7709   if (oinsn)
7710     *pinsn = oinsn;
7711
7712   return oinsn != 0;
7713 }
7714
7715 /* Linker hasn't found the correct merge section for non-section symbol
7716    in relax time, this work is left to the function elf_link_input_bfd().
7717    So for non-section symbol, _bfd_merged_section_offset is also needed
7718    to find the correct symbol address.  */
7719
7720 static bfd_vma
7721 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7722                           asection **psec, Elf_Internal_Rela *rel)
7723 {
7724   asection *sec = *psec;
7725   bfd_vma relocation;
7726
7727   relocation = (sec->output_section->vma
7728                 + sec->output_offset + sym->st_value);
7729   if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7730     {
7731       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7732         rel->r_addend =
7733           _bfd_merged_section_offset (abfd, psec,
7734                                       elf_section_data (sec)->sec_info,
7735                                       sym->st_value + rel->r_addend);
7736       else
7737         rel->r_addend =
7738           _bfd_merged_section_offset (abfd, psec,
7739                                       elf_section_data (sec)->sec_info,
7740                                       sym->st_value) + rel->r_addend;
7741
7742       if (sec != *psec)
7743         {
7744           /* If we have changed the section, and our original section is
7745              marked with SEC_EXCLUDE, it means that the original
7746              SEC_MERGE section has been completely subsumed in some
7747              other SEC_MERGE section.  In this case, we need to leave
7748              some info around for --emit-relocs.  */
7749           if ((sec->flags & SEC_EXCLUDE) != 0)
7750             sec->kept_section = *psec;
7751           sec = *psec;
7752         }
7753       rel->r_addend -= relocation;
7754       rel->r_addend += sec->output_section->vma + sec->output_offset;
7755     }
7756   return relocation;
7757 }
7758
7759 static bfd_vma
7760 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
7761                           Elf_Internal_Sym *isymbuf,
7762                           Elf_Internal_Shdr *symtab_hdr)
7763 {
7764   bfd_signed_vma foff;
7765   bfd_vma symval, addend;
7766   Elf_Internal_Rela irel_fn;
7767   Elf_Internal_Sym *isym;
7768   asection *sym_sec;
7769
7770   /* Get the value of the symbol referred to by the reloc.  */
7771   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7772     {
7773       /* A local symbol.  */
7774       isym = isymbuf + ELF32_R_SYM (irel->r_info);
7775
7776       if (isym->st_shndx == SHN_UNDEF)
7777         sym_sec = bfd_und_section_ptr;
7778       else if (isym->st_shndx == SHN_ABS)
7779         sym_sec = bfd_abs_section_ptr;
7780       else if (isym->st_shndx == SHN_COMMON)
7781         sym_sec = bfd_com_section_ptr;
7782       else
7783         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7784       memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
7785       symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
7786       addend = irel_fn.r_addend;
7787     }
7788   else
7789     {
7790       unsigned long indx;
7791       struct elf_link_hash_entry *h;
7792
7793       /* An external symbol.  */
7794       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7795       h = elf_sym_hashes (abfd)[indx];
7796       BFD_ASSERT (h != NULL);
7797
7798       while (h->root.type == bfd_link_hash_indirect
7799              || h->root.type == bfd_link_hash_warning)
7800         h = (struct elf_link_hash_entry *) h->root.u.i.link;
7801
7802       if (h->root.type != bfd_link_hash_defined
7803           && h->root.type != bfd_link_hash_defweak)
7804         /* This appears to be a reference to an undefined
7805            symbol.  Just ignore it--it will be caught by the
7806            regular reloc processing.  */
7807         return 0;
7808
7809       if (h->root.u.def.section->flags & SEC_MERGE)
7810         {
7811           sym_sec = h->root.u.def.section;
7812           symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
7813                                                (sym_sec)->sec_info, h->root.u.def.value);
7814           symval = symval + sym_sec->output_section->vma
7815                    + sym_sec->output_offset;
7816         }
7817       else
7818         symval = (h->root.u.def.value
7819                   + h->root.u.def.section->output_section->vma
7820                   + h->root.u.def.section->output_offset);
7821       addend = irel->r_addend;
7822     }
7823
7824   foff = symval + addend;
7825
7826   return foff;
7827 }
7828
7829 static bfd_vma
7830 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
7831                               Elf_Internal_Rela *irel,
7832                               Elf_Internal_Shdr *symtab_hdr)
7833 {
7834   int symndx;
7835   bfd_vma *local_got_offsets;
7836   /* Get the value of the symbol referred to by the reloc.  */
7837   struct elf_link_hash_entry *h;
7838   struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
7839
7840   /* An external symbol.  */
7841   symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7842   h = elf_sym_hashes (abfd)[symndx];
7843   while (h->root.type == bfd_link_hash_indirect
7844          || h->root.type == bfd_link_hash_warning)
7845     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7846
7847   if (symndx >= 0)
7848     {
7849       BFD_ASSERT (h != NULL);
7850       return (htab->root.sgot->output_section->vma
7851               + htab->root.sgot->output_offset
7852               + h->got.offset);
7853     }
7854   else
7855     {
7856       local_got_offsets = elf_local_got_offsets (abfd);
7857       BFD_ASSERT (local_got_offsets != NULL);
7858       return (htab->root.sgot->output_section->vma
7859               + htab->root.sgot->output_offset
7860               + local_got_offsets[ELF32_R_SYM (irel->r_info)]);
7861     }
7862
7863   /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?).  */
7864   /* The check of h->root.type is passed.  */
7865 }
7866
7867 static int
7868 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
7869               asection *sec, Elf_Internal_Rela *rel)
7870 {
7871   bfd_byte *contents;
7872   unsigned short insn16;
7873
7874   if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
7875     return FALSE;
7876   contents = elf_section_data (sec)->this_hdr.contents;
7877   insn16 = bfd_getb16 (contents + rel->r_offset);
7878   if (insn16 == NDS32_NOP16)
7879     return TRUE;
7880   return FALSE;
7881 }
7882
7883 /* It checks whether the instruction could be converted to
7884    16-bit form and returns the converted one.
7885
7886    `internal_relocs' is supposed to be sorted.  */
7887
7888 static int
7889 is_convert_32_to_16 (bfd *abfd, asection *sec,
7890                      Elf_Internal_Rela *reloc,
7891                      Elf_Internal_Rela *internal_relocs,
7892                      Elf_Internal_Rela *irelend,
7893                      uint16_t *insn16)
7894 {
7895 #define NORMAL_32_TO_16 (1 << 0)
7896 #define SPECIAL_32_TO_16 (1 << 1)
7897   bfd_byte *contents = NULL;
7898   bfd_signed_vma off;
7899   bfd_vma mem_addr;
7900   uint32_t insn = 0;
7901   Elf_Internal_Rela *pc_rel;
7902   int pic_ext_target = 0;
7903   Elf_Internal_Shdr *symtab_hdr;
7904   Elf_Internal_Sym *isymbuf = NULL;
7905   int convert_type;
7906   bfd_vma offset;
7907
7908   if (reloc->r_offset + 4 > sec->size)
7909     return FALSE;
7910
7911   offset = reloc->r_offset;
7912
7913   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
7914     return FALSE;
7915   insn = bfd_getb32 (contents + offset);
7916
7917   if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
7918     convert_type = NORMAL_32_TO_16;
7919   else if (special_convert_32_to_16 (insn, insn16, reloc))
7920     convert_type = SPECIAL_32_TO_16;
7921   else
7922     return FALSE;
7923
7924   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7925   if (!nds32_get_local_syms (abfd, sec, &isymbuf))
7926     return FALSE;
7927
7928   /* Find the first relocation of the same relocation-type,
7929      so we iteratie them forward.  */
7930   pc_rel = reloc;
7931   while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
7932     pc_rel--;
7933
7934   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
7935     {
7936       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
7937           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
7938           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
7939           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
7940         {
7941           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
7942                                   &pic_ext_target);
7943           if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
7944               || off == 0)
7945             return FALSE;
7946           break;
7947         }
7948       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
7949         {
7950           /* movi => movi55  */
7951           mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
7952                                                symtab_hdr);
7953           /* mem_addr is unsigned, but the value should
7954              be between [-16, 15].  */
7955           if ((mem_addr + 0x10) >> 5)
7956             return FALSE;
7957           break;
7958         }
7959       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
7960                || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
7961         {
7962           /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
7963              because it can be relaxed to addi for TLS_LE_ADD.  */
7964           return FALSE;
7965         }
7966       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
7967                 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
7968                && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
7969                && convert_type == SPECIAL_32_TO_16)
7970         {
7971           /* fp-as-gp
7972              We've selected a best fp-base for this access, so we can
7973              always resolve it anyway.  Do nothing.  */
7974           break;
7975         }
7976       else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
7977                 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
7978                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
7979                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
7980                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
7981                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
7982         {
7983           /* Prevent unresolved addi instruction translate
7984              to addi45 or addi333.  */
7985           return FALSE;
7986         }
7987       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
7988         {
7989           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
7990                                   &pic_ext_target);
7991           if (off >= ACCURATE_U9BIT_S1 || off <= 0)
7992             return FALSE;
7993           break;
7994         }
7995     }
7996
7997   return TRUE;
7998 }
7999
8000 static void
8001 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8002                     Elf_Internal_Rela *reloc,
8003                     Elf_Internal_Rela *internal_relocs,
8004                     Elf_Internal_Rela *irelend,
8005                     unsigned short insn16)
8006 {
8007   Elf_Internal_Rela *pc_rel;
8008   bfd_vma offset;
8009
8010   offset = reloc->r_offset;
8011   bfd_putb16 (insn16, contents + offset);
8012   /* Find the first relocation of the same relocation-type,
8013      so we iteratie them forward.  */
8014   pc_rel = reloc;
8015   while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8016     pc_rel--;
8017
8018   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8019     {
8020       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8021           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8022           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8023         {
8024           pc_rel->r_info =
8025             ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8026         }
8027       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8028         pc_rel->r_info =
8029           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8030       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8031         pc_rel->r_info =
8032           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8033       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8034                || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8035         pc_rel->r_info =
8036           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8037       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8038         pc_rel->r_info =
8039           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8040     }
8041 }
8042
8043 /* Find a relocation of type specified by `reloc_type'
8044    of the same r_offset with reloc.
8045    If not found, return irelend.
8046
8047    Assuming relocations are sorted by r_offset,
8048    we find the relocation from `reloc' backward untill relocs,
8049    or find it from `reloc' forward untill irelend.  */
8050
8051 static Elf_Internal_Rela *
8052 find_relocs_at_address (Elf_Internal_Rela *reloc,
8053                         Elf_Internal_Rela *relocs,
8054                         Elf_Internal_Rela *irelend,
8055                         enum elf_nds32_reloc_type reloc_type)
8056 {
8057   Elf_Internal_Rela *rel_t;
8058
8059   /* Find backward.  */
8060   for (rel_t = reloc;
8061        rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8062        rel_t--)
8063     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8064       return rel_t;
8065
8066   /* We didn't find it backward.  Try find it forward.  */
8067   for (rel_t = reloc;
8068        rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8069        rel_t++)
8070     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8071       return rel_t;
8072
8073   return irelend;
8074 }
8075
8076 /* Find a relocation of specified type and offset.
8077    `reloc' is just a refence point to find a relocation at specified offset.
8078    If not found, return irelend.
8079
8080    Assuming relocations are sorted by r_offset,
8081    we find the relocation from `reloc' backward untill relocs,
8082    or find it from `reloc' forward untill irelend.  */
8083
8084 static Elf_Internal_Rela *
8085 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8086                              Elf_Internal_Rela *relocs,
8087                              Elf_Internal_Rela *irelend,
8088                              enum elf_nds32_reloc_type reloc_type,
8089                              bfd_vma offset_p)
8090 {
8091   Elf_Internal_Rela *rel_t = NULL;
8092
8093   /* First, we try to find a relocation of offset `offset_p',
8094      and then we use find_relocs_at_address to find specific type.  */
8095
8096   if (reloc->r_offset > offset_p)
8097     {
8098       /* Find backward.  */
8099       for (rel_t = reloc;
8100            rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8101         /* Do nothing.  */;
8102     }
8103   else if (reloc->r_offset < offset_p)
8104     {
8105       /* Find forward.  */
8106       for (rel_t = reloc;
8107            rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8108         /* Do nothing.  */;
8109     }
8110   else
8111     rel_t = reloc;
8112
8113   /* Not found?  */
8114   if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8115     return irelend;
8116
8117   return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8118 }
8119
8120 static bfd_boolean
8121 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8122                             Elf_Internal_Rela *internal_relocs,
8123                             Elf_Internal_Rela *irelend,
8124                             unsigned char reloc_type)
8125 {
8126   Elf_Internal_Rela *rel_t;
8127
8128   for (rel_t = reloc;
8129        rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8130        rel_t--)
8131     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8132       {
8133         if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8134             && rel_t->r_addend == reloc->r_addend)
8135           continue;
8136         return TRUE;
8137       }
8138
8139   for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8140        rel_t++)
8141     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8142       {
8143         if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8144             && rel_t->r_addend == reloc->r_addend)
8145           continue;
8146         return TRUE;
8147       }
8148
8149   return FALSE;
8150 }
8151
8152 typedef struct nds32_elf_blank nds32_elf_blank_t;
8153 struct nds32_elf_blank
8154 {
8155   /* Where the blank begins.  */
8156   bfd_vma offset;
8157   /* The size of the blank.  */
8158   bfd_vma size;
8159   /* The accumulative size before this blank.  */
8160   bfd_vma total_size;
8161   nds32_elf_blank_t *next;
8162   nds32_elf_blank_t *prev;
8163 };
8164
8165 static nds32_elf_blank_t *blank_free_list = NULL;
8166
8167 static nds32_elf_blank_t *
8168 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8169 {
8170   nds32_elf_blank_t *blank_t;
8171
8172   if (blank_free_list)
8173     {
8174       blank_t = blank_free_list;
8175       blank_free_list = blank_free_list->next;
8176     }
8177   else
8178     blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8179
8180   if (blank_t == NULL)
8181     return NULL;
8182
8183   blank_t->offset = offset_p;
8184   blank_t->size = size_p;
8185   blank_t->total_size = 0;
8186   blank_t->next = NULL;
8187   blank_t->prev = NULL;
8188
8189   return blank_t;
8190 }
8191
8192 static void
8193 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8194 {
8195   if (blank_free_list)
8196     {
8197       blank_free_list->prev = blank_p;
8198       blank_p->next = blank_free_list;
8199     }
8200   else
8201     blank_p->next = NULL;
8202
8203   blank_p->prev = NULL;
8204   blank_free_list = blank_p;
8205 }
8206
8207 static void
8208 clean_nds32_elf_blank (void)
8209 {
8210   nds32_elf_blank_t *blank_t;
8211
8212   while (blank_free_list)
8213     {
8214       blank_t = blank_free_list;
8215       blank_free_list = blank_free_list->next;
8216       free (blank_t);
8217     }
8218 }
8219
8220 static nds32_elf_blank_t *
8221 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8222 {
8223   nds32_elf_blank_t *blank_t;
8224
8225   if (!blank_p)
8226     return NULL;
8227   blank_t = blank_p;
8228
8229   while (blank_t && addr < blank_t->offset)
8230     blank_t = blank_t->prev;
8231   while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8232     blank_t = blank_t->next;
8233
8234   return blank_t;
8235 }
8236
8237 static bfd_vma
8238 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8239                            int overwrite)
8240 {
8241   nds32_elf_blank_t *blank_t;
8242
8243   blank_t = search_nds32_elf_blank (*blank_p, addr);
8244   if (!blank_t)
8245     return 0;
8246
8247   if (overwrite)
8248     *blank_p = blank_t;
8249
8250   if (addr < blank_t->offset + blank_t->size)
8251     return blank_t->total_size + (addr - blank_t->offset);
8252   else
8253     return blank_t->total_size + blank_t->size;
8254 }
8255
8256 static bfd_boolean
8257 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8258 {
8259   nds32_elf_blank_t *blank_t, *blank_t2;
8260
8261   if (!*blank_p)
8262     {
8263       *blank_p = create_nds32_elf_blank (addr, len);
8264       return *blank_p ? TRUE : FALSE;
8265     }
8266
8267   blank_t = search_nds32_elf_blank (*blank_p, addr);
8268
8269   if (blank_t == NULL)
8270     {
8271       blank_t = create_nds32_elf_blank (addr, len);
8272       if (!blank_t)
8273         return FALSE;
8274       while ((*blank_p)->prev != NULL)
8275         *blank_p = (*blank_p)->prev;
8276       blank_t->next = *blank_p;
8277       (*blank_p)->prev = blank_t;
8278       (*blank_p) = blank_t;
8279       return TRUE;
8280     }
8281
8282   if (addr < blank_t->offset + blank_t->size)
8283     {
8284       if (addr > blank_t->offset + blank_t->size)
8285         blank_t->size = addr - blank_t->offset;
8286     }
8287   else
8288     {
8289       blank_t2 = create_nds32_elf_blank (addr, len);
8290       if (!blank_t2)
8291         return FALSE;
8292       if (blank_t->next)
8293         {
8294           blank_t->next->prev = blank_t2;
8295           blank_t2->next = blank_t->next;
8296         }
8297       blank_t2->prev = blank_t;
8298       blank_t->next = blank_t2;
8299       *blank_p = blank_t2;
8300     }
8301
8302   return TRUE;
8303 }
8304
8305 static bfd_boolean
8306 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8307                                      bfd_vma len)
8308 {
8309   nds32_elf_blank_t *blank_t;
8310
8311   if (!insert_nds32_elf_blank (blank_p, addr, len))
8312     return FALSE;
8313
8314   blank_t = *blank_p;
8315
8316   if (!blank_t->prev)
8317     {
8318       blank_t->total_size = 0;
8319       blank_t = blank_t->next;
8320     }
8321
8322   while (blank_t)
8323     {
8324       blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8325       blank_t = blank_t->next;
8326     }
8327
8328   return TRUE;
8329 }
8330
8331 static void
8332 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8333 {
8334   nds32_elf_blank_t *blank_t;
8335   bfd_vma total_size = 0;
8336
8337   if (!blank_p)
8338     return;
8339
8340   blank_t = blank_p;
8341   while (blank_t->prev)
8342     blank_t = blank_t->prev;
8343   while (blank_t)
8344     {
8345       blank_t->total_size = total_size;
8346       total_size += blank_t->size;
8347       blank_t = blank_t->next;
8348     }
8349 }
8350
8351 static bfd_boolean
8352 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8353                                nds32_elf_blank_t *blank_p)
8354 {
8355   Elf_Internal_Shdr *symtab_hdr;        /* Symbol table header of this bfd.  */
8356   Elf_Internal_Sym *isym = NULL;        /* Symbol table of this bfd.  */
8357   Elf_Internal_Sym *isymend;            /* Symbol entry iterator.  */
8358   unsigned int sec_shndx;               /* The section the be relaxed.  */
8359   bfd_byte *contents;                   /* Contents data of iterating section.  */
8360   Elf_Internal_Rela *internal_relocs;
8361   Elf_Internal_Rela *irel;
8362   Elf_Internal_Rela *irelend;
8363   struct elf_link_hash_entry **sym_hashes;
8364   struct elf_link_hash_entry **end_hashes;
8365   unsigned int symcount;
8366   asection *sect;
8367   nds32_elf_blank_t *blank_t;
8368   nds32_elf_blank_t *blank_t2;
8369   nds32_elf_blank_t *blank_head;
8370
8371   blank_head = blank_t = blank_p;
8372   while (blank_head->prev != NULL)
8373     blank_head = blank_head->prev;
8374   while (blank_t->next != NULL)
8375     blank_t = blank_t->next;
8376
8377   if (blank_t->offset + blank_t->size <= sec->size)
8378     {
8379       blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8380       blank_t->next->prev = blank_t;
8381     }
8382   if (blank_head->offset > 0)
8383     {
8384       blank_head->prev = create_nds32_elf_blank (0, 0);
8385       blank_head->prev->next = blank_head;
8386       blank_head = blank_head->prev;
8387     }
8388
8389   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8390
8391   /* The deletion must stop at the next ALIGN reloc for an alignment
8392      power larger than the number of bytes we are deleting.  */
8393
8394   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8395   if (!nds32_get_local_syms (abfd, sec, &isym))
8396     return FALSE;
8397
8398   if (isym == NULL)
8399     {
8400       isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8401                                    symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8402       symtab_hdr->contents = (bfd_byte *) isym;
8403     }
8404
8405   if (isym == NULL || symtab_hdr->sh_info == 0)
8406     return FALSE;
8407
8408   blank_t = blank_head;
8409   calc_nds32_blank_total (blank_head);
8410
8411   for (sect = abfd->sections; sect != NULL; sect = sect->next)
8412     {
8413       /* Adjust all the relocs.  */
8414
8415       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
8416       internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8417                                                    TRUE /* keep_memory */);
8418       irelend = internal_relocs + sect->reloc_count;
8419
8420       blank_t = blank_head;
8421       blank_t2 = blank_head;
8422
8423       if (!(sect->flags & SEC_RELOC))
8424         continue;
8425
8426       nds32_get_section_contents (abfd, sect, &contents, TRUE);
8427
8428       for (irel = internal_relocs; irel < irelend; irel++)
8429         {
8430           bfd_vma raddr;
8431
8432           if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8433               && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8434               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8435             {
8436               unsigned long val = 0;
8437               unsigned long mask;
8438               long before, between;
8439               long offset = 0;
8440
8441               switch (ELF32_R_TYPE (irel->r_info))
8442                 {
8443                 case R_NDS32_DIFF8:
8444                   offset = bfd_get_8 (abfd, contents + irel->r_offset);
8445                   break;
8446                 case R_NDS32_DIFF16:
8447                   offset = bfd_get_16 (abfd, contents + irel->r_offset);
8448                   break;
8449                 case R_NDS32_DIFF32:
8450                   val = bfd_get_32 (abfd, contents + irel->r_offset);
8451                   /* Get the signed bit and mask for the high part.  The
8452                      gcc will alarm when right shift 32-bit since the
8453                      type size of long may be 32-bit.  */
8454                   mask = 0 - (val >> 31);
8455                   if (mask)
8456                     offset = (val | (mask - 0xffffffff));
8457                   else
8458                     offset = val;
8459                   break;
8460                 default:
8461                   BFD_ASSERT (0);
8462                 }
8463
8464               /*                  DIFF value
8465                 0            |encoded in location|
8466                 |------------|-------------------|---------
8467                             sym+off(addend)
8468                 -- before ---| *****************
8469                 --------------------- between ---|
8470
8471                 We only care how much data are relax between DIFF,
8472                 marked as ***.  */
8473
8474               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8475               between = get_nds32_elf_blank_total (&blank_t,
8476                                                    irel->r_addend + offset, 0);
8477               if (between == before)
8478                 goto done_adjust_diff;
8479
8480               switch (ELF32_R_TYPE (irel->r_info))
8481                 {
8482                 case R_NDS32_DIFF8:
8483                   bfd_put_8 (abfd, offset - (between - before),
8484                              contents + irel->r_offset);
8485                   break;
8486                 case R_NDS32_DIFF16:
8487                   bfd_put_16 (abfd, offset - (between - before),
8488                               contents + irel->r_offset);
8489                   break;
8490                 case R_NDS32_DIFF32:
8491                   bfd_put_32 (abfd, offset - (between - before),
8492                               contents + irel->r_offset);
8493                   break;
8494                 }
8495             }
8496           else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8497               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8498             {
8499               bfd_vma val = 0;
8500               unsigned int len = 0;
8501               unsigned long before, between;
8502               bfd_byte *endp, *p;
8503
8504               val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
8505                                                &len);
8506
8507               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8508               between = get_nds32_elf_blank_total (&blank_t,
8509                                                    irel->r_addend + val, 0);
8510               if (between == before)
8511                 goto done_adjust_diff;
8512
8513               p = contents + irel->r_offset;
8514               endp = p + len -1;
8515               memset (p, 0x80, len);
8516               *(endp) = 0;
8517               p = write_uleb128 (p, val - (between - before)) - 1;
8518               if (p < endp)
8519                 *p |= 0x80;
8520             }
8521 done_adjust_diff:
8522
8523           if (sec == sect)
8524             {
8525               raddr = irel->r_offset;
8526               irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8527                                                            irel->r_offset, 1);
8528
8529               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8530                 continue;
8531               if (blank_t2 && blank_t2->next
8532                   && (blank_t2->offset > raddr
8533                       || blank_t2->next->offset <= raddr))
8534                 _bfd_error_handler
8535                   (_("%B: Error: search_nds32_elf_blank reports wrong node\n"), abfd);
8536
8537               /* Mark reloc in deleted portion as NONE.
8538                  For some relocs like R_NDS32_LABEL that doesn't modify the
8539                  content in the section.  R_NDS32_LABEL doesn't belong to the
8540                  instruction in the section, so we should preserve it.  */
8541               if (raddr >= blank_t2->offset
8542                   && raddr < blank_t2->offset + blank_t2->size
8543                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8544                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8545                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8546                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8547                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8548                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8549                 {
8550                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8551                                                R_NDS32_NONE);
8552                   continue;
8553                 }
8554             }
8555
8556           if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8557               || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8558               || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8559             continue;
8560
8561           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8562               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8563               && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8564             {
8565               if (irel->r_addend <= sec->size)
8566                 irel->r_addend -=
8567                   get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8568             }
8569         }
8570     }
8571
8572   /* Adjust the local symbols defined in this section.  */
8573   blank_t = blank_head;
8574   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8575     {
8576       if (isym->st_shndx == sec_shndx)
8577         {
8578           if (isym->st_value <= sec->size)
8579             {
8580               bfd_vma ahead;
8581               bfd_vma orig_addr = isym->st_value;
8582
8583               ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8584               isym->st_value -= ahead;
8585
8586               /* Adjust function size.  */
8587               if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8588                   && isym->st_size > 0)
8589                 isym->st_size -=
8590                   get_nds32_elf_blank_total
8591                   (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8592             }
8593         }
8594     }
8595
8596   /* Now adjust the global symbols defined in this section.  */
8597   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8598               - symtab_hdr->sh_info);
8599   sym_hashes = elf_sym_hashes (abfd);
8600   end_hashes = sym_hashes + symcount;
8601   blank_t = blank_head;
8602   for (; sym_hashes < end_hashes; sym_hashes++)
8603     {
8604       struct elf_link_hash_entry *sym_hash = *sym_hashes;
8605
8606       if ((sym_hash->root.type == bfd_link_hash_defined
8607            || sym_hash->root.type == bfd_link_hash_defweak)
8608           && sym_hash->root.u.def.section == sec)
8609         {
8610           if (sym_hash->root.u.def.value <= sec->size)
8611             {
8612               bfd_vma ahead;
8613               bfd_vma orig_addr = sym_hash->root.u.def.value;
8614
8615               ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8616               sym_hash->root.u.def.value -= ahead;
8617
8618               /* Adjust function size.  */
8619               if (sym_hash->type == STT_FUNC)
8620                 sym_hash->size -=
8621                   get_nds32_elf_blank_total
8622                   (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8623
8624             }
8625         }
8626     }
8627
8628   contents = elf_section_data (sec)->this_hdr.contents;
8629   blank_t = blank_head;
8630   while (blank_t->next)
8631     {
8632       /* Actually delete the bytes.  */
8633
8634       /* If current blank is the last blank overlap with current section,
8635          go to finish process.  */
8636       if (sec->size <= (blank_t->next->offset))
8637         break;
8638
8639       memmove (contents + blank_t->offset - blank_t->total_size,
8640                contents + blank_t->offset + blank_t->size,
8641                blank_t->next->offset - (blank_t->offset + blank_t->size));
8642
8643       blank_t = blank_t->next;
8644     }
8645
8646   if (sec->size > (blank_t->offset + blank_t->size))
8647     {
8648       /* There are remaining code between blank and section boundary.
8649          Move the remaining code to appropriate location.  */
8650       memmove (contents + blank_t->offset - blank_t->total_size,
8651                contents + blank_t->offset + blank_t->size,
8652                sec->size - (blank_t->offset + blank_t->size));
8653       sec->size -= blank_t->total_size + blank_t->size;
8654     }
8655   else
8656     /* This blank is not entirely included in the section,
8657        reduce the section size by only part of the blank size.  */
8658     sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8659
8660   while (blank_head)
8661     {
8662       blank_t = blank_head;
8663       blank_head = blank_head->next;
8664       remove_nds32_elf_blank (blank_t);
8665     }
8666
8667   return TRUE;
8668 }
8669
8670 /* Get the contents of a section.  */
8671
8672 static int
8673 nds32_get_section_contents (bfd *abfd, asection *sec,
8674                             bfd_byte **contents_p, bfd_boolean cache)
8675 {
8676   /* Get the section contents.  */
8677   if (elf_section_data (sec)->this_hdr.contents != NULL)
8678     *contents_p = elf_section_data (sec)->this_hdr.contents;
8679   else
8680     {
8681       if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8682         return FALSE;
8683       if (cache)
8684         elf_section_data (sec)->this_hdr.contents = *contents_p;
8685     }
8686
8687   return TRUE;
8688 }
8689
8690 /* Get the contents of the internal symbol of abfd.  */
8691
8692 static int
8693 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8694                       Elf_Internal_Sym **isymbuf_p)
8695 {
8696   Elf_Internal_Shdr *symtab_hdr;
8697   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8698
8699   /* Read this BFD's local symbols if we haven't done so already.  */
8700   if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8701     {
8702       *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8703       if (*isymbuf_p == NULL)
8704         {
8705           *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8706                                              symtab_hdr->sh_info, 0,
8707                                              NULL, NULL, NULL);
8708           if (*isymbuf_p == NULL)
8709             return FALSE;
8710         }
8711     }
8712   symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8713
8714   return TRUE;
8715 }
8716
8717 /* Range of small data.  */
8718 static bfd_vma sdata_range[2][2];
8719 static bfd_vma const sdata_init_range[2] =
8720 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8721
8722 static int
8723 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8724                      bfd_byte *contents, bfd_vma addr)
8725 {
8726   unsigned long insn = bfd_getb32 (contents + addr);
8727
8728   if (insn & 0x80000000)
8729     return 2;
8730
8731   return 4;
8732 }
8733
8734 /* Set the gp relax range.  We have to measure the safe range
8735    to do gp relaxation.  */
8736
8737 static void
8738 relax_range_measurement (bfd *abfd)
8739 {
8740   asection *sec_f, *sec_b;
8741   /* For upper bound.   */
8742   bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8743   bfd_vma align;
8744   static int decide_relax_range = 0;
8745   int i;
8746   int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8747
8748   if (decide_relax_range)
8749     return;
8750   decide_relax_range = 1;
8751
8752   if (sda_rela_sec == NULL)
8753     {
8754       /* Since there is no data sections, we assume the range is page size.  */
8755       for (i = 0; i < range_number; i++)
8756         {
8757           sdata_range[i][0] = sdata_init_range[i] - 0x1000;
8758           sdata_range[i][1] = sdata_init_range[i] - 0x1000;
8759         }
8760       return;
8761     }
8762
8763   /* Get the biggest alignment power after the gp located section.  */
8764   sec_f = sda_rela_sec->output_section;
8765   sec_b = sec_f->next;
8766   align = 0;
8767   while (sec_b != NULL)
8768     {
8769       if ((unsigned)(1 << sec_b->alignment_power) > align)
8770         align = (1 << sec_b->alignment_power);
8771       sec_b = sec_b->next;
8772     }
8773
8774   /* I guess we can not determine the section before
8775      gp located section, so we assume the align is max page size.  */
8776   for (i = 0; i < range_number; i++)
8777     {
8778       sdata_range[i][1] = sdata_init_range[i] - align;
8779       BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
8780       sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
8781       BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
8782     }
8783 }
8784
8785 /* These are macros used to check flags encoded in r_addend.
8786    They are only used by nds32_elf_relax_section ().  */
8787 #define GET_SEQ_LEN(addend)     ((addend) & 0x000000ff)
8788 #define IS_1ST_CONVERT(addend)  ((addend) & 0x80000000)
8789 #define IS_OPTIMIZE(addend)     ((addend) & 0x40000000)
8790 #define IS_16BIT_ON(addend)     ((addend) & 0x20000000)
8791
8792 static const char * unrecognized_reloc_msg =
8793   /* xgettext:c-format */
8794   N_("%B: warning: %s points to unrecognized reloc at %#Lx");
8795
8796 /* Relax LONGCALL1 relocation for nds32_elf_relax_section.  */
8797
8798 static bfd_boolean
8799 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
8800                            Elf_Internal_Rela *internal_relocs, int *insn_len,
8801                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
8802                            Elf_Internal_Shdr *symtab_hdr)
8803 {
8804   /* There are 3 variations for LONGCALL1
8805      case 4-4-2; 16-bit on, optimize off or optimize for space
8806      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
8807      ori   ta, ta, lo12(symbol) ; LO12S0
8808      jral5 ta                   ;
8809
8810      case 4-4-4; 16-bit off, optimize don't care
8811      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
8812      ori   ta, ta, lo12(symbol) ; LO12S0
8813      jral  ta                   ;
8814
8815      case 4-4-4; 16-bit on, optimize for speed
8816      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
8817      ori   ta, ta, lo12(symbol) ; LO12S0
8818      jral  ta                   ;
8819      Check code for -mlong-calls output.  */
8820
8821   /* Get the reloc for the address from which the register is
8822      being loaded.  This reloc will tell us which function is
8823      actually being called.  */
8824
8825   bfd_vma laddr;
8826   int seq_len;  /* Original length of instruction sequence.  */
8827   uint32_t insn;
8828   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
8829   int pic_ext_target = 0;
8830   bfd_signed_vma foff;
8831   uint16_t insn16;
8832
8833   irelend = internal_relocs + sec->reloc_count;
8834   seq_len = GET_SEQ_LEN (irel->r_addend);
8835   laddr = irel->r_offset;
8836   *insn_len = seq_len;
8837
8838   hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
8839                                            R_NDS32_HI20_RELA, laddr);
8840   lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
8841                                            R_NDS32_LO12S0_ORI_RELA,
8842                                            laddr + 4);
8843
8844   if (hi_irelfn == irelend || lo_irelfn == irelend)
8845     {
8846       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
8847                           irel->r_offset);
8848       return FALSE;
8849     }
8850
8851   /* Get the value of the symbol referred to by the reloc.  */
8852   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
8853                            &pic_ext_target);
8854
8855   /* This condition only happened when symbol is undefined.  */
8856   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
8857       || foff >= CONSERVATIVE_24BIT_S1)
8858     return FALSE;
8859
8860   /* Relax to: jal symbol; 25_PCREL */
8861   /* For simplicity of coding, we are going to modify the section
8862      contents, the section relocs, and the BFD symbol table.  We
8863      must tell the rest of the code not to free up this
8864      information.  It would be possible to instead create a table
8865      of changes which have to be made, as is done in coff-mips.c;
8866      that would be more work, but would require less memory when
8867      the linker is run.  */
8868
8869   /* Replace the long call with a jal.  */
8870   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
8871                                R_NDS32_25_PCREL_RELA);
8872   irel->r_addend = hi_irelfn->r_addend;
8873
8874   /* We don't resolve this here but resolve it in relocate_section.  */
8875   insn = INSN_JAL;
8876   bfd_putb32 (insn, contents + irel->r_offset);
8877
8878   hi_irelfn->r_info =
8879     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
8880   lo_irelfn->r_info =
8881     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
8882   *insn_len = 4;
8883
8884   if (seq_len & 0x2)
8885     {
8886       insn16 = NDS32_NOP16;
8887       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
8888       lo_irelfn->r_info =
8889         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
8890       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
8891       *insn_len += 2;
8892     }
8893   return TRUE;
8894 }
8895
8896 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
8897 /* Relax LONGCALL2 relocation for nds32_elf_relax_section.  */
8898
8899 static bfd_boolean
8900 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
8901                            Elf_Internal_Rela *internal_relocs, int *insn_len,
8902                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
8903                            Elf_Internal_Shdr *symtab_hdr)
8904 {
8905   /* bltz  rt, .L1   ; LONGCALL2
8906      jal   symbol   ; 25_PCREL
8907      .L1: */
8908
8909   /* Get the reloc for the address from which the register is
8910      being loaded.  This reloc will tell us which function is
8911      actually being called.  */
8912
8913   bfd_vma laddr;
8914   uint32_t insn;
8915   Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
8916   int pic_ext_target = 0;
8917   bfd_signed_vma foff;
8918
8919   irelend = internal_relocs + sec->reloc_count;
8920   laddr = irel->r_offset;
8921   i1_irelfn =
8922     find_relocs_at_address_addr (irel, internal_relocs, irelend,
8923                                  R_NDS32_25_PCREL_RELA, laddr + 4);
8924
8925   if (i1_irelfn == irelend)
8926     {
8927       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
8928                           irel->r_offset);
8929       return FALSE;
8930     }
8931
8932   insn = bfd_getb32 (contents + laddr);
8933
8934   /* Get the value of the symbol referred to by the reloc.  */
8935   foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
8936                            &pic_ext_target);
8937
8938   if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
8939       || foff >= CONSERVATIVE_16BIT_S1)
8940     return FALSE;
8941
8942   /* Relax to   bgezal   rt, label ; 17_PCREL
8943      or         bltzal   rt, label ; 17_PCREL */
8944
8945   /* Convert to complimentary conditional call.  */
8946   insn = CONVERT_CONDITION_CALL (insn);
8947
8948   /* For simplicity of coding, we are going to modify the section
8949      contents, the section relocs, and the BFD symbol table.  We
8950      must tell the rest of the code not to free up this
8951      information.  It would be possible to instead create a table
8952      of changes which have to be made, as is done in coff-mips.c;
8953      that would be more work, but would require less memory when
8954      the linker is run.  */
8955
8956   /* Clean unnessary relocations.  */
8957   i1_irelfn->r_info =
8958     ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
8959   cond_irelfn =
8960     find_relocs_at_address_addr (irel, internal_relocs, irelend,
8961                                  R_NDS32_17_PCREL_RELA, laddr);
8962   if (cond_irelfn != irelend)
8963     cond_irelfn->r_info =
8964       ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
8965
8966   /* Replace the long call with a bgezal.  */
8967   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
8968                                R_NDS32_17_PCREL_RELA);
8969   irel->r_addend = i1_irelfn->r_addend;
8970
8971   bfd_putb32 (insn, contents + irel->r_offset);
8972
8973   *insn_len = 4;
8974   return TRUE;
8975 }
8976
8977 /* Relax LONGCALL3 relocation for nds32_elf_relax_section.  */
8978
8979 static bfd_boolean
8980 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
8981                            Elf_Internal_Rela *internal_relocs, int *insn_len,
8982                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
8983                            Elf_Internal_Shdr *symtab_hdr)
8984 {
8985   /* There are 3 variations for LONGCALL3
8986      case 4-4-4-2; 16-bit on, optimize off or optimize for space
8987      bltz  rt,   $1                ; LONGCALL3
8988      sethi ta,   hi20(symbol)      ; HI20
8989      ori   ta, ta,  lo12(symbol)   ; LO12S0
8990      jral5 ta                      ;
8991      $1
8992
8993      case 4-4-4-4; 16-bit off, optimize don't care
8994      bltz  rt,   $1                ; LONGCALL3
8995      sethi ta,   hi20(symbol)      ; HI20
8996      ori   ta, ta,  lo12(symbol)   ; LO12S0
8997      jral  ta                      ;
8998      $1
8999
9000      case 4-4-4-4; 16-bit on, optimize for speed
9001      bltz  rt,   $1                ; LONGCALL3
9002      sethi ta,   hi20(symbol)      ; HI20
9003      ori   ta, ta,  lo12(symbol)   ; LO12S0
9004      jral  ta                      ;
9005      $1 */
9006
9007   /* Get the reloc for the address from which the register is
9008      being loaded.  This reloc will tell us which function is
9009      actually being called.  */
9010
9011   bfd_vma laddr;
9012   int seq_len;  /* Original length of instruction sequence.  */
9013   uint32_t insn;
9014   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9015   int pic_ext_target = 0;
9016   bfd_signed_vma foff;
9017   uint16_t insn16;
9018
9019   irelend = internal_relocs + sec->reloc_count;
9020   seq_len = GET_SEQ_LEN (irel->r_addend);
9021   laddr = irel->r_offset;
9022   *insn_len = seq_len;
9023
9024   hi_irelfn =
9025     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9026                                  R_NDS32_HI20_RELA, laddr + 4);
9027   lo_irelfn =
9028     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9029                                  R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9030
9031   if (hi_irelfn == irelend || lo_irelfn == irelend)
9032     {
9033       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9034                           irel->r_offset);
9035       return FALSE;
9036     }
9037
9038   /* Get the value of the symbol referred to by the reloc.  */
9039   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9040                            &pic_ext_target);
9041
9042   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9043       || foff >= CONSERVATIVE_24BIT_S1)
9044     return FALSE;
9045
9046   insn = bfd_getb32 (contents + laddr);
9047   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9048     {
9049       /* Relax to  bgezal   rt, label ; 17_PCREL
9050          or        bltzal   rt, label ; 17_PCREL */
9051
9052       /* Convert to complimentary conditional call.  */
9053       insn = CONVERT_CONDITION_CALL (insn);
9054       bfd_putb32 (insn, contents + irel->r_offset);
9055
9056       *insn_len = 4;
9057       irel->r_info =
9058         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9059       hi_irelfn->r_info =
9060         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9061       lo_irelfn->r_info =
9062         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9063
9064       cond_irelfn =
9065         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9066                                      R_NDS32_17_PCREL_RELA, laddr);
9067       if (cond_irelfn != irelend)
9068         {
9069           cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9070                                               R_NDS32_17_PCREL_RELA);
9071           cond_irelfn->r_addend = hi_irelfn->r_addend;
9072         }
9073
9074       if (seq_len & 0x2)
9075         {
9076           insn16 = NDS32_NOP16;
9077           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9078           hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9079                                             R_NDS32_INSN16);
9080           hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9081           insn_len += 2;
9082         }
9083     }
9084   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9085     {
9086       /* Relax to the following instruction sequence
9087          bltz  rt,   $1 ; LONGCALL2
9088          jal   symbol   ; 25_PCREL
9089          $1     */
9090       *insn_len = 8;
9091       insn = INSN_JAL;
9092       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9093
9094       hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9095                                         R_NDS32_25_PCREL_RELA);
9096       irel->r_info =
9097         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9098
9099       lo_irelfn->r_info =
9100         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9101
9102       if (seq_len & 0x2)
9103         {
9104           insn16 = NDS32_NOP16;
9105           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9106           lo_irelfn->r_info =
9107             ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9108           lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9109           insn_len += 2;
9110         }
9111     }
9112   return TRUE;
9113 }
9114
9115 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section.  */
9116
9117 static bfd_boolean
9118 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9119                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9120                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9121                            Elf_Internal_Shdr *symtab_hdr)
9122 {
9123   /* There are 3 variations for LONGJUMP1
9124      case 4-4-2; 16-bit bit on, optimize off or optimize for space
9125      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9126      ori   ta, ta, lo12(symbol)  ; LO12S0
9127      jr5   ta                    ;
9128
9129      case 4-4-4; 16-bit off, optimize don't care
9130      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9131      ori   ta, ta, lo12(symbol)  ; LO12S0
9132      jr    ta                    ;
9133
9134      case 4-4-4; 16-bit on, optimize for speed
9135      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9136      ori   ta, ta, lo12(symbol)  ; LO12S0
9137      jr    ta                    ;      */
9138
9139   /* Get the reloc for the address from which the register is
9140      being loaded.  This reloc will tell us which function is
9141      actually being called.  */
9142
9143   bfd_vma laddr;
9144   int seq_len;  /* Original length of instruction sequence.  */
9145   int insn16_on;        /* 16-bit on/off.  */
9146   uint32_t insn;
9147   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9148   int pic_ext_target = 0;
9149   bfd_signed_vma foff;
9150   uint16_t insn16;
9151   unsigned long reloc;
9152
9153   irelend = internal_relocs + sec->reloc_count;
9154   seq_len = GET_SEQ_LEN (irel->r_addend);
9155   laddr = irel->r_offset;
9156   *insn_len = seq_len;
9157   insn16_on = IS_16BIT_ON (irel->r_addend);
9158
9159   hi_irelfn =
9160     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9161                                  R_NDS32_HI20_RELA, laddr);
9162   lo_irelfn =
9163     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9164                                  R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9165   if (hi_irelfn == irelend || lo_irelfn == irelend)
9166     {
9167       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
9168                           irel->r_offset);
9169       return FALSE;
9170     }
9171
9172   /* Get the value of the symbol referred to by the reloc.  */
9173   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9174                            &pic_ext_target);
9175
9176   if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9177       || foff < -CONSERVATIVE_24BIT_S1)
9178     return FALSE;
9179
9180   if (insn16_on && foff >= -ACCURATE_8BIT_S1
9181       && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9182     {
9183       /* j8     label */
9184       /* 16-bit on, but not optimized for speed.  */
9185       reloc = R_NDS32_9_PCREL_RELA;
9186       insn16 = INSN_J8;
9187       bfd_putb16 (insn16, contents + irel->r_offset);
9188       *insn_len = 2;
9189       irel->r_info =
9190         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9191     }
9192   else
9193     {
9194       /* j     label */
9195       reloc = R_NDS32_25_PCREL_RELA;
9196       insn = INSN_J;
9197       bfd_putb32 (insn, contents + irel->r_offset);
9198       *insn_len = 4;
9199       irel->r_info =
9200         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9201       irel->r_addend = 0;
9202     }
9203
9204   hi_irelfn->r_info =
9205     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9206   lo_irelfn->r_info =
9207     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9208
9209   if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9210     {
9211       insn16 = NDS32_NOP16;
9212       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9213       lo_irelfn->r_info =
9214         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9215                       R_NDS32_INSN16);
9216       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9217       *insn_len += 2;
9218     }
9219   return TRUE;
9220 }
9221
9222 /* Revert condition branch.  This function does not check if the input
9223    instruction is condition branch or not.  */
9224
9225 static void
9226 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9227                            uint16_t *re_insn16, uint32_t *re_insn)
9228 {
9229   uint32_t comp_insn = 0;
9230   uint16_t comp_insn16 = 0;
9231
9232   if (insn)
9233     {
9234       if (N32_OP6 (insn) == N32_OP6_BR1)
9235         {
9236           /* beqs label.  */
9237           comp_insn = (insn ^ 0x4000) & 0xffffc000;
9238           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9239             {
9240               /* Insn can be contracted to 16-bit implied r5.  */
9241               comp_insn16 =
9242                 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9243               comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9244             }
9245         }
9246       else if (N32_OP6 (insn) == N32_OP6_BR3)
9247         {
9248           /* bnec $ta, imm11, label.  */
9249           comp_insn = (insn ^ 0x80000) & 0xffffff00;
9250         }
9251       else
9252         {
9253           comp_insn = (insn ^ 0x10000) & 0xffffc000;
9254           if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9255               || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9256             {
9257               if (N32_IS_RT3 (insn))
9258                 {
9259                   /* Insn can be contracted to 16-bit.  */
9260                   comp_insn16 =
9261                     (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9262                   comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9263                 }
9264               else if (N32_RT5 (insn) == REG_R15)
9265                 {
9266                   /* Insn can be contracted to 16-bit.  */
9267                   comp_insn16 =
9268                     (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9269                 }
9270             }
9271         }
9272     }
9273   else
9274     {
9275       switch ((insn16 & 0xf000) >> 12)
9276         {
9277         case 0xc:
9278           /* beqz38 or bnez38 */
9279           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9280           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9281           comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9282           break;
9283
9284         case 0xd:
9285           /* beqs38 or bnes38 */
9286           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9287           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9288           comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9289             | (REG_R5 << 15);
9290           break;
9291
9292         case 0xe:
9293           /* beqzS8 or bnezS8 */
9294           comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9295           comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9296           comp_insn |= REG_R15 << 20;
9297           break;
9298
9299         default:
9300           break;
9301         }
9302     }
9303   if (comp_insn && re_insn)
9304     *re_insn = comp_insn;
9305   if (comp_insn16 && re_insn16)
9306     *re_insn16 = comp_insn16;
9307 }
9308
9309 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section.  */
9310
9311 static bfd_boolean
9312 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9313                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9314                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9315                            Elf_Internal_Shdr *symtab_hdr)
9316 {
9317   /* There are 3 variations for LONGJUMP2
9318      case 2-4;  1st insn convertible, 16-bit on,
9319      optimize off or optimize for space
9320      bnes38  rt, ra, $1 ; LONGJUMP2
9321      j       label      ; 25_PCREL
9322      $1:
9323
9324      case 4-4; 1st insn not convertible
9325      bne  rt, ra, $1 ; LONGJUMP2
9326      j    label      ; 25_PCREL
9327      $1:
9328
9329      case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9330      bne  rt, ra, $1 ; LONGJUMP2
9331      j    label      ; 25_PCREL
9332      $1: */
9333
9334   /* Get the reloc for the address from which the register is
9335      being loaded.  This reloc will tell us which function is
9336      actually being called.  */
9337
9338   bfd_vma laddr;
9339   int seq_len;  /* Original length of instruction sequence.  */
9340   Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9341   int pic_ext_target = 0, first_size;
9342   unsigned int i;
9343   bfd_signed_vma foff;
9344   uint32_t insn, re_insn = 0;
9345   uint16_t insn16, re_insn16 = 0;
9346   unsigned long reloc, cond_reloc;
9347
9348   enum elf_nds32_reloc_type checked_types[] =
9349     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9350
9351   irelend = internal_relocs + sec->reloc_count;
9352   seq_len = GET_SEQ_LEN (irel->r_addend);
9353   laddr = irel->r_offset;
9354   *insn_len = seq_len;
9355   first_size = (seq_len == 6) ? 2 : 4;
9356
9357   i2_irelfn =
9358     find_relocs_at_address_addr (irel, internal_relocs,
9359                                  irelend, R_NDS32_25_PCREL_RELA,
9360                                  laddr + first_size);
9361
9362   for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9363     {
9364       cond_irelfn =
9365         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9366                                      checked_types[i], laddr);
9367       if (cond_irelfn != irelend)
9368         break;
9369     }
9370
9371   if (i2_irelfn == irelend || cond_irelfn == irelend)
9372     {
9373       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
9374                           irel->r_offset);
9375       return FALSE;
9376     }
9377
9378   /* Get the value of the symbol referred to by the reloc.  */
9379   foff =
9380     calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9381                       &pic_ext_target);
9382   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9383       || foff >= CONSERVATIVE_16BIT_S1)
9384     return FALSE;
9385
9386   /* Get the all corresponding instructions.  */
9387   if (first_size == 4)
9388     {
9389       insn = bfd_getb32 (contents + laddr);
9390       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9391     }
9392   else
9393     {
9394       insn16 = bfd_getb16 (contents + laddr);
9395       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9396     }
9397
9398   if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9399       && foff < ACCURATE_8BIT_S1 - first_size)
9400     {
9401       if (first_size == 4)
9402         {
9403           /* Don't convert it to 16-bit now, keep this as relaxable for
9404              ``label reloc; INSN16''.  */
9405
9406           /* Save comp_insn32 to buffer.  */
9407           bfd_putb32 (re_insn, contents + irel->r_offset);
9408           *insn_len = 4;
9409           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9410             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9411           cond_reloc = R_NDS32_INSN16;
9412         }
9413       else
9414         {
9415           bfd_putb16 (re_insn16, contents + irel->r_offset);
9416           *insn_len = 2;
9417           reloc = R_NDS32_9_PCREL_RELA;
9418           cond_reloc = R_NDS32_NONE;
9419         }
9420     }
9421   else if (N32_OP6 (re_insn) == N32_OP6_BR1
9422            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9423                && foff < ACCURATE_14BIT_S1 - first_size))
9424     {
9425       /* beqs     label    ; 15_PCREL */
9426       bfd_putb32 (re_insn, contents + irel->r_offset);
9427       *insn_len = 4;
9428       reloc = R_NDS32_15_PCREL_RELA;
9429       cond_reloc = R_NDS32_NONE;
9430     }
9431   else if (N32_OP6 (re_insn) == N32_OP6_BR2
9432            && foff >= -CONSERVATIVE_16BIT_S1
9433            && foff < CONSERVATIVE_16BIT_S1)
9434     {
9435       /* beqz     label ; 17_PCREL */
9436       bfd_putb32 (re_insn, contents + irel->r_offset);
9437       *insn_len = 4;
9438       reloc = R_NDS32_17_PCREL_RELA;
9439       cond_reloc = R_NDS32_NONE;
9440     }
9441   else
9442     return FALSE;
9443
9444   /* Set all relocations.  */
9445   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9446   irel->r_addend = i2_irelfn->r_addend;
9447
9448   cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9449                                       cond_reloc);
9450   cond_irelfn->r_addend = 0;
9451
9452   if ((seq_len ^ *insn_len ) & 0x2)
9453     {
9454       insn16 = NDS32_NOP16;
9455       bfd_putb16 (insn16, contents + irel->r_offset + 4);
9456       i2_irelfn->r_offset = 4;
9457       i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9458                                         R_NDS32_INSN16);
9459       i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9460       *insn_len += 2;
9461     }
9462   else
9463     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9464                                       R_NDS32_NONE);
9465   return TRUE;
9466 }
9467
9468 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section.  */
9469
9470 static bfd_boolean
9471 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9472                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9473                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9474                            Elf_Internal_Shdr *symtab_hdr)
9475 {
9476   /* There are 5 variations for LONGJUMP3
9477      case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9478      optimize off or optimize for space
9479      bnes38   rt, ra, $1            ; LONGJUMP3
9480      sethi    ta, hi20(symbol)      ; HI20
9481      ori      ta, ta, lo12(symbol)  ; LO12S0
9482      jr5      ta                    ;
9483      $1:                            ;
9484
9485      case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9486      bnes38   rt, ra, $1           ; LONGJUMP3
9487      sethi    ta, hi20(symbol)     ; HI20
9488      ori      ta, ta, lo12(symbol) ; LO12S0
9489      jr5      ta                   ;
9490      $1:                           ; LABEL
9491
9492      case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9493      optimize off or optimize for space
9494      bne   rt, ra, $1           ; LONGJUMP3
9495      sethi ta, hi20(symbol)     ; HI20
9496      ori   ta, ta, lo12(symbol) ; LO12S0
9497      jr5   ta                   ;
9498      $1:                        ;
9499
9500      case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9501      16-bit off if no INSN16
9502      bne   rt, ra, $1           ; LONGJUMP3
9503      sethi ta, hi20(symbol)     ; HI20
9504      ori   ta, ta, lo12(symbol) ; LO12S0
9505      jr    ta                   ;
9506      $1:                        ;
9507
9508      case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9509      16-bit off if no INSN16
9510      bne   rt, ra, $1           ; LONGJUMP3
9511      sethi ta, hi20(symbol)     ; HI20
9512      ori   ta, ta, lo12(symbol) ; LO12S0
9513      jr    ta                   ;
9514      $1:                        ; LABEL */
9515
9516   /* Get the reloc for the address from which the register is
9517      being loaded.  This reloc will tell us which function is
9518      actually being called.  */
9519   enum elf_nds32_reloc_type checked_types[] =
9520     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9521
9522   int reloc_off = 0, cond_removed = 0, convertible;
9523   bfd_vma laddr;
9524   int seq_len;  /* Original length of instruction sequence.  */
9525   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9526   int pic_ext_target = 0, first_size;
9527   unsigned int i;
9528   bfd_signed_vma foff;
9529   uint32_t insn, re_insn = 0;
9530   uint16_t insn16, re_insn16 = 0;
9531   unsigned long reloc, cond_reloc;
9532
9533   irelend = internal_relocs + sec->reloc_count;
9534   seq_len = GET_SEQ_LEN (irel->r_addend);
9535   laddr = irel->r_offset;
9536   *insn_len = seq_len;
9537
9538   convertible = IS_1ST_CONVERT (irel->r_addend);
9539
9540   if (convertible)
9541     first_size = 2;
9542   else
9543     first_size = 4;
9544
9545   /* Get all needed relocations.  */
9546   hi_irelfn =
9547     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9548                                  R_NDS32_HI20_RELA, laddr + first_size);
9549   lo_irelfn =
9550     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9551                                  R_NDS32_LO12S0_ORI_RELA,
9552                                  laddr + first_size + 4);
9553
9554   for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9555     {
9556       cond_irelfn =
9557         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9558                                      checked_types[i], laddr);
9559       if (cond_irelfn != irelend)
9560         break;
9561     }
9562
9563   if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9564     {
9565       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
9566                           irel->r_offset);
9567       return FALSE;
9568     }
9569
9570   /* Get the value of the symbol referred to by the reloc.  */
9571   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9572                            &pic_ext_target);
9573
9574   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9575       || foff >= CONSERVATIVE_24BIT_S1)
9576     return FALSE;
9577
9578   /* Get the all corresponding instructions.  */
9579   if (first_size == 4)
9580     {
9581       insn = bfd_getb32 (contents + laddr);
9582       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9583     }
9584   else
9585     {
9586       insn16 = bfd_getb16 (contents + laddr);
9587       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9588     }
9589
9590   /* For simplicity of coding, we are going to modify the section
9591      contents, the section relocs, and the BFD symbol table.  We
9592      must tell the rest of the code not to free up this
9593      information.  It would be possible to instead create a table
9594      of changes which have to be made, as is done in coff-mips.c;
9595      that would be more work, but would require less memory when
9596      the linker is run.  */
9597
9598   if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9599       && foff < ACCURATE_8BIT_S1 - first_size)
9600     {
9601       if (!(seq_len & 0x2))
9602         {
9603           /* Don't convert it to 16-bit now, keep this as relaxable
9604              for ``label reloc; INSN1a''6.  */
9605           /* Save comp_insn32 to buffer.  */
9606           bfd_putb32 (re_insn, contents + irel->r_offset);
9607           *insn_len = 4;
9608           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9609             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9610           cond_reloc = R_NDS32_INSN16;
9611         }
9612       else
9613         {
9614           /* Not optimize for speed; convert sequence to 16-bit.  */
9615           /* Save comp_insn16 to buffer.  */
9616           bfd_putb16 (re_insn16, contents + irel->r_offset);
9617           *insn_len = 2;
9618           reloc = R_NDS32_9_PCREL_RELA;
9619           cond_reloc = R_NDS32_NONE;
9620         }
9621       cond_removed = 1;
9622     }
9623   else if (N32_OP6 (re_insn) == N32_OP6_BR1
9624            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9625                && foff < ACCURATE_14BIT_S1 - first_size))
9626     {
9627       /* beqs     label    ; 15_PCREL */
9628       bfd_putb32 (re_insn, contents + irel->r_offset);
9629       *insn_len = 4;
9630       reloc = R_NDS32_15_PCREL_RELA;
9631       cond_reloc = R_NDS32_NONE;
9632       cond_removed = 1;
9633     }
9634   else if (N32_OP6 (re_insn) == N32_OP6_BR2
9635            && foff >= -CONSERVATIVE_16BIT_S1
9636            && foff < CONSERVATIVE_16BIT_S1)
9637     {
9638       /* beqz     label ; 17_PCREL */
9639       bfd_putb32 (re_insn, contents + irel->r_offset);
9640       *insn_len = 4;
9641       reloc = R_NDS32_17_PCREL_RELA;
9642       cond_reloc = R_NDS32_NONE;
9643       cond_removed = 1;
9644     }
9645   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9646            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9647     {
9648       /* Relax to one of the following 3 variations
9649
9650          case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9651          for space
9652          bnes38  rt, $1 ; LONGJUMP2
9653          j       label  ; 25_PCREL
9654          $1
9655
9656          case 4-4; 1st insn not convertible, others don't care
9657          bne   rt, ra, $1 ; LONGJUMP2
9658          j     label      ; 25_PCREL
9659          $1
9660
9661          case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9662          bne   rt, ra, $1 ; LONGJUMP2
9663          j     label      ; 25_PCREL
9664          $1 */
9665
9666       /* Offset for first instruction.  */
9667
9668       /* Use j label as second instruction.  */
9669       *insn_len = 4 + first_size;
9670       insn = INSN_J;
9671       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9672       reloc = R_NDS32_LONGJUMP2;
9673       cond_reloc = R_NDS32_25_PLTREL;
9674     }
9675     else
9676       return FALSE;
9677
9678     if (cond_removed == 1)
9679       {
9680         /* Set all relocations.  */
9681         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9682         irel->r_addend = hi_irelfn->r_addend;
9683
9684         cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9685                                             cond_reloc);
9686         cond_irelfn->r_addend = 0;
9687         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9688                                           R_NDS32_NONE);
9689       }
9690     else
9691       {
9692         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9693         irel->r_addend = irel->r_addend;
9694         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9695                                           cond_reloc);
9696       }
9697
9698   if ((seq_len ^ *insn_len ) & 0x2)
9699     {
9700       insn16 = NDS32_NOP16;
9701       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9702       lo_irelfn->r_offset = *insn_len;
9703       lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9704                                         R_NDS32_INSN16);
9705       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9706       *insn_len += 2;
9707     }
9708   else
9709     lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9710                                       R_NDS32_NONE);
9711   return TRUE;
9712 }
9713
9714 /* Relax LONGCALL4 relocation for nds32_elf_relax_section.  */
9715
9716 static bfd_boolean
9717 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9718                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9719                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9720                            Elf_Internal_Shdr *symtab_hdr)
9721 {
9722   /* The pattern for LONGCALL4.  Support for function cse.
9723      sethi ta, hi20(symbol)     ; LONGCALL4/HI20
9724      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9725      jral  ta                   ; PTR_RES/EMPTY/INSN16  */
9726
9727   bfd_vma laddr;
9728   uint32_t insn;
9729   Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9730   Elf_Internal_Rela *irelend;
9731   int pic_ext_target = 0;
9732   bfd_signed_vma foff;
9733
9734   irelend = internal_relocs + sec->reloc_count;
9735   laddr = irel->r_offset;
9736
9737   /* Get the reloc for the address from which the register is
9738      being loaded.  This reloc will tell us which function is
9739      actually being called.  */
9740   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9741                                          R_NDS32_HI20_RELA, laddr);
9742
9743   if (hi_irel == irelend)
9744     {
9745       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
9746                           irel->r_offset);
9747       return FALSE;
9748     }
9749
9750   /* Get the value of the symbol referred to by the reloc.  */
9751   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
9752                            &pic_ext_target);
9753
9754   /* This condition only happened when symbol is undefined.  */
9755   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9756       || foff >= CONSERVATIVE_24BIT_S1)
9757     return FALSE;
9758
9759   /* Relax to: jal symbol; 25_PCREL */
9760   /* For simplicity of coding, we are going to modify the section
9761      contents, the section relocs, and the BFD symbol table.  We
9762      must tell the rest of the code not to free up this
9763      information.  It would be possible to instead create a table
9764      of changes which have to be made, as is done in coff-mips.c;
9765      that would be more work, but would require less memory when
9766      the linker is run.  */
9767
9768   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9769                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
9770   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9771                                           R_NDS32_EMPTY, irel->r_addend);
9772
9773   if (ptr_irel == irelend || em_irel == irelend)
9774     {
9775       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
9776                           irel->r_offset);
9777       return FALSE;
9778     }
9779   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
9780   insn = bfd_getb32 (contents + irel->r_addend);
9781   if (insn & 0x80000000)
9782     return FALSE;
9783
9784   /* Replace the long call with a jal.  */
9785   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
9786                                   R_NDS32_25_PCREL_RELA);
9787   ptr_irel->r_addend = 1;
9788
9789   /* We don't resolve this here but resolve it in relocate_section.  */
9790   insn = INSN_JAL;
9791   bfd_putb32 (insn, contents + em_irel->r_offset);
9792
9793   irel->r_info =
9794     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9795
9796   /* If there is function cse, HI20 can not remove now.  */
9797   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9798                                            R_NDS32_LONGCALL4, laddr);
9799   if (call_irel == irelend)
9800     {
9801       *insn_len = 0;
9802       hi_irel->r_info =
9803         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
9804     }
9805
9806   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9807                                           R_NDS32_INSN16, irel->r_addend);
9808   if (insn_irel != irelend)
9809     insn_irel->r_info =
9810       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9811
9812   return TRUE;
9813 }
9814
9815 /* Relax LONGCALL5 relocation for nds32_elf_relax_section.  */
9816
9817 static bfd_boolean
9818 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9819                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9820                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9821                            Elf_Internal_Shdr *symtab_hdr)
9822 {
9823   /* The pattern for LONGCALL5.
9824      bltz  rt, .L1      ; LONGCALL5/17_PCREL
9825      jal   symbol       ; 25_PCREL
9826      .L1:  */
9827
9828   bfd_vma laddr;
9829   uint32_t insn;
9830   Elf_Internal_Rela *cond_irel, *irelend;
9831   int pic_ext_target = 0;
9832   bfd_signed_vma foff;
9833
9834   irelend = internal_relocs + sec->reloc_count;
9835   laddr = irel->r_offset;
9836   insn = bfd_getb32 (contents + laddr);
9837
9838   /* Get the reloc for the address from which the register is
9839      being loaded.  This reloc will tell us which function is
9840      actually being called.  */
9841   cond_irel =
9842     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9843                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
9844   if (cond_irel == irelend)
9845     {
9846       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
9847                           irel->r_offset);
9848       return FALSE;
9849     }
9850
9851   /* Get the value of the symbol referred to by the reloc.  */
9852   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
9853                            &pic_ext_target);
9854
9855   if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9856       || foff >= CONSERVATIVE_16BIT_S1)
9857     return FALSE;
9858
9859   /* Relax to   bgezal   rt, label ; 17_PCREL
9860      or         bltzal   rt, label ; 17_PCREL */
9861
9862   /* Convert to complimentary conditional call.  */
9863   insn = CONVERT_CONDITION_CALL (insn);
9864
9865   /* For simplicity of coding, we are going to modify the section
9866      contents, the section relocs, and the BFD symbol table.  We
9867      must tell the rest of the code not to free up this
9868      information.  It would be possible to instead create a table
9869      of changes which have to be made, as is done in coff-mips.c;
9870      that would be more work, but would require less memory when
9871      the linker is run.  */
9872
9873   /* Modify relocation and contents.  */
9874   cond_irel->r_info =
9875     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
9876
9877   /* Replace the long call with a bgezal.  */
9878   bfd_putb32 (insn, contents + cond_irel->r_offset);
9879   *insn_len = 0;
9880
9881   /* Clean unnessary relocations.  */
9882   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9883
9884   cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9885                                            R_NDS32_17_PCREL_RELA, laddr);
9886   cond_irel->r_info =
9887     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
9888
9889   return TRUE;
9890 }
9891
9892 /* Relax LONGCALL6 relocation for nds32_elf_relax_section.  */
9893
9894 static bfd_boolean
9895 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9896                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9897                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9898                            Elf_Internal_Shdr *symtab_hdr)
9899 {
9900   /* The pattern for LONGCALL6.
9901      bltz  rt,   .L1                    ; LONGCALL6/17_PCREL
9902      sethi ta,   hi20(symbol)           ; HI20/PTR
9903      ori   ta, ta,  lo12(symbol)        ; LO12S0_ORI/PTR
9904      jral  ta                           ; PTR_RES/EMPTY/INSN16
9905      .L1  */
9906
9907   bfd_vma laddr;
9908   uint32_t insn;
9909   Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
9910   int pic_ext_target = 0;
9911   bfd_signed_vma foff;
9912
9913   irelend = internal_relocs + sec->reloc_count;
9914   laddr = irel->r_offset;
9915
9916   /* Get the reloc for the address from which the register is
9917      being loaded.  This reloc will tell us which function is
9918      actually being called.  */
9919   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9920                                          R_NDS32_EMPTY, irel->r_addend);
9921
9922   if (em_irel == irelend)
9923     {
9924       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
9925                           irel->r_offset);
9926       return FALSE;
9927     }
9928
9929   /* Get the value of the symbol referred to by the reloc.  */
9930   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
9931                            &pic_ext_target);
9932
9933   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9934       || foff >= CONSERVATIVE_24BIT_S1)
9935     return FALSE;
9936
9937   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
9938   insn = bfd_getb32 (contents + irel->r_addend);
9939   if (insn & 0x80000000)
9940     return FALSE;
9941
9942   insn = bfd_getb32 (contents + laddr);
9943   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9944     {
9945       /* Relax to  bgezal   rt, label ; 17_PCREL
9946          or        bltzal   rt, label ; 17_PCREL */
9947
9948       /* Convert to complimentary conditional call.  */
9949       *insn_len = 0;
9950       insn = CONVERT_CONDITION_CALL (insn);
9951       bfd_putb32 (insn, contents + em_irel->r_offset);
9952
9953       em_irel->r_info =
9954         ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
9955
9956       /* Set resolved relocation.  */
9957       cond_irel =
9958         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9959                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
9960       if (cond_irel == irelend)
9961         {
9962           _bfd_error_handler (unrecognized_reloc_msg, abfd,
9963                               "R_NDS32_LONGCALL6", irel->r_offset);
9964           return FALSE;
9965         }
9966       cond_irel->r_addend = 1;
9967
9968       /* Clear relocations.  */
9969
9970       irel->r_info =
9971         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9972
9973       cond_irel =
9974         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9975                                      R_NDS32_17_PCREL_RELA, laddr);
9976       if (cond_irel != irelend)
9977         cond_irel->r_info =
9978           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
9979
9980       cond_irel =
9981         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9982                                      R_NDS32_INSN16, irel->r_addend);
9983       if (cond_irel != irelend)
9984         cond_irel->r_info =
9985           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
9986
9987     }
9988   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9989     {
9990       /* Relax to the following instruction sequence
9991          bltz  rt, .L1  ; LONGCALL2/17_PCREL
9992          jal   symbol   ; 25_PCREL/PTR_RES
9993          .L1  */
9994       *insn_len = 4;
9995       /* Convert instruction.  */
9996       insn = INSN_JAL;
9997       bfd_putb32 (insn, contents + em_irel->r_offset);
9998
9999       /* Convert relocations.  */
10000       em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10001                                       R_NDS32_25_PCREL_RELA);
10002       irel->r_info =
10003         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10004
10005       /* Set resolved relocation.  */
10006       cond_irel =
10007         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10008                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10009       if (cond_irel == irelend)
10010         {
10011           _bfd_error_handler (unrecognized_reloc_msg, abfd,
10012                               "R_NDS32_LONGCALL6", irel->r_offset);
10013           return FALSE;
10014         }
10015       cond_irel->r_addend = 1;
10016
10017       cond_irel =
10018         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10019                                      R_NDS32_INSN16, irel->r_addend);
10020       if (cond_irel != irelend)
10021         cond_irel->r_info =
10022           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10023     }
10024   return TRUE;
10025 }
10026
10027 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section.  */
10028
10029 static bfd_boolean
10030 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10031                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10032                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10033                            Elf_Internal_Shdr *symtab_hdr)
10034 {
10035   /* The pattern for LONGJUMP4.
10036      sethi ta, hi20(symbol)     ; LONGJUMP4/HI20
10037      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10038      jr    ta                   ; PTR_RES/INSN16/EMPTY  */
10039
10040   bfd_vma laddr;
10041   int seq_len;  /* Original length of instruction sequence.  */
10042   uint32_t insn;
10043   Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10044   int pic_ext_target = 0;
10045   bfd_signed_vma foff;
10046
10047   irelend = internal_relocs + sec->reloc_count;
10048   seq_len = GET_SEQ_LEN (irel->r_addend);
10049   laddr = irel->r_offset;
10050   *insn_len = seq_len;
10051
10052   /* Get the reloc for the address from which the register is
10053      being loaded.  This reloc will tell us which function is
10054      actually being called.  */
10055
10056   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10057                                          R_NDS32_HI20_RELA, laddr);
10058
10059   if (hi_irel == irelend)
10060     {
10061       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10062                           irel->r_offset);
10063       return FALSE;
10064     }
10065
10066   /* Get the value of the symbol referred to by the reloc.  */
10067   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10068                            &pic_ext_target);
10069
10070   if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10071       || foff < -CONSERVATIVE_24BIT_S1)
10072     return FALSE;
10073
10074   /* Convert it to "j label", it may be converted to j8 in the final
10075      pass of relaxation.  Therefore, we do not consider this currently.  */
10076   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10077                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
10078   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10079                                          R_NDS32_EMPTY, irel->r_addend);
10080
10081   if (ptr_irel == irelend || em_irel == irelend)
10082     {
10083       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10084                           irel->r_offset);
10085       return FALSE;
10086     }
10087
10088   em_irel->r_info =
10089     ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10090   ptr_irel->r_addend = 1;
10091
10092   /* Write instruction.  */
10093   insn = INSN_J;
10094   bfd_putb32 (insn, contents + em_irel->r_offset);
10095
10096   /* Clear relocations.  */
10097   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10098
10099   /* If there is function cse, HI20 can not remove now.  */
10100   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10101                                            R_NDS32_LONGJUMP4, laddr);
10102   if (call_irel == irelend)
10103     {
10104       *insn_len = 0;
10105       hi_irel->r_info =
10106         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10107     }
10108
10109   return TRUE;
10110 }
10111
10112 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section.  */
10113
10114 static bfd_boolean
10115 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10116                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10117                            int *seq_len, bfd_byte *contents,
10118                            Elf_Internal_Sym *isymbuf,
10119                            Elf_Internal_Shdr *symtab_hdr)
10120 {
10121   /* There are 2 variations for LONGJUMP5
10122      case 2-4;  1st insn convertible, 16-bit on.
10123      bnes38  rt, ra, .L1        ; LONGJUMP5/9_PCREL/INSN16
10124      j       label              ; 25_PCREL/INSN16
10125      $1:
10126
10127      case 4-4; 1st insn not convertible
10128      bne  rt, ra, .L1   ; LONGJUMP5/15_PCREL/INSN16
10129      j    label         ; 25_PCREL/INSN16
10130      .L1:  */
10131
10132   bfd_vma laddr;
10133   Elf_Internal_Rela *cond_irel,  *irelend;
10134   int pic_ext_target = 0;
10135   unsigned int i;
10136   bfd_signed_vma foff;
10137   uint32_t insn, re_insn = 0;
10138   uint16_t insn16, re_insn16 = 0;
10139   unsigned long reloc;
10140
10141   enum elf_nds32_reloc_type checked_types[] =
10142     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10143       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10144
10145   irelend = internal_relocs + sec->reloc_count;
10146   laddr = irel->r_offset;
10147
10148   /* Get the reloc for the address from which the register is
10149      being loaded.  This reloc will tell us which function is
10150      actually being called.  */
10151
10152   cond_irel =
10153     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10154                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
10155   if (cond_irel == irelend)
10156     {
10157       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
10158                           irel->r_offset);
10159       return FALSE;
10160     }
10161
10162   /* Get the value of the symbol referred to by the reloc.  */
10163   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10164                            &pic_ext_target);
10165
10166   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10167       || foff >= CONSERVATIVE_16BIT_S1)
10168     return FALSE;
10169
10170   /* Get the all corresponding instructions.  */
10171   insn = bfd_getb32 (contents + laddr);
10172   /* Check instruction size.  */
10173   if (insn & 0x80000000)
10174     {
10175       *seq_len = 0;
10176       insn16 = insn >> 16;
10177       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10178     }
10179   else
10180     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10181
10182   if (N32_OP6 (re_insn) == N32_OP6_BR1
10183       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10184     {
10185       /* beqs label ; 15_PCREL.  */
10186       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10187       reloc = R_NDS32_15_PCREL_RELA;
10188     }
10189   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10190            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10191     {
10192       /* beqz label ; 17_PCREL.  */
10193       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10194       reloc = R_NDS32_17_PCREL_RELA;
10195     }
10196   else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10197            && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10198     {
10199       /* beqc label ; 9_PCREL.  */
10200       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10201       reloc = R_NDS32_WORD_9_PCREL_RELA;
10202     }
10203   else
10204     return FALSE;
10205
10206   /* Set all relocations.  */
10207   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10208
10209   /* Clean relocations.  */
10210   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10211   for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10212     {
10213       cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10214                                                checked_types[i], laddr);
10215       if (cond_irel != irelend)
10216         {
10217           if (*seq_len == 0
10218               && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10219             {
10220               /* If the branch instruction is 2 byte, it cannot remove
10221                  directly.  Only convert it to nop16 and remove it after
10222                  checking alignment issue.  */
10223               insn16 = NDS32_NOP16;
10224               bfd_putb16 (insn16, contents + laddr);
10225               cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10226             }
10227           else
10228             cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10229                                               R_NDS32_NONE);
10230         }
10231     }
10232   *insn_len = 0;
10233
10234   return TRUE;
10235 }
10236
10237 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section.  */
10238
10239 static bfd_boolean
10240 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10241                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10242                            int *seq_len, bfd_byte *contents,
10243                            Elf_Internal_Sym *isymbuf,
10244                            Elf_Internal_Shdr *symtab_hdr)
10245 {
10246   /* There are 5 variations for LONGJUMP6
10247      case : 2-4-4-4; 1st insn convertible, 16-bit on.
10248      bnes38   rt, ra, .L1               ; LONGJUMP6/15_PCREL/INSN16
10249      sethi    ta, hi20(symbol)          ; HI20/PTR
10250      ori      ta, ta, lo12(symbol)      ; LO12S0_ORI/PTR
10251      jr       ta                        ; PTR_RES/INSN16/EMPTY
10252      .L1:
10253
10254      case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10255      bne   rt, ra, .L1          ; LONGJUMP6/15_PCREL/INSN16
10256      sethi ta, hi20(symbol)     ; HI20/PTR
10257      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10258      jr    ta                   ; PTR_RES/INSN16/EMPTY
10259      .L1:  */
10260
10261   enum elf_nds32_reloc_type checked_types[] =
10262     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10263       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10264
10265   int reloc_off = 0, cond_removed = 0;
10266   bfd_vma laddr;
10267   Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10268   int pic_ext_target = 0;
10269   unsigned int i;
10270   bfd_signed_vma foff;
10271   uint32_t insn, re_insn = 0;
10272   uint16_t insn16, re_insn16 = 0;
10273   unsigned long reloc;
10274
10275   irelend = internal_relocs + sec->reloc_count;
10276   laddr = irel->r_offset;
10277
10278   /* Get the reloc for the address from which the register is
10279      being loaded.  This reloc will tell us which function is
10280      actually being called.  */
10281   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10282                                          R_NDS32_EMPTY, irel->r_addend);
10283
10284   if (em_irel == irelend)
10285     {
10286       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
10287                           irel->r_offset);
10288       return FALSE;
10289     }
10290
10291   /* Get the value of the symbol referred to by the reloc.  */
10292   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10293                            &pic_ext_target);
10294
10295   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10296       || foff >= CONSERVATIVE_24BIT_S1)
10297     return FALSE;
10298
10299   insn = bfd_getb32 (contents + laddr);
10300   /* Check instruction size.  */
10301   if (insn & 0x80000000)
10302     {
10303       *seq_len = 0;
10304       insn16 = insn >> 16;
10305       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10306     }
10307   else
10308     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10309
10310   /* For simplicity of coding, we are going to modify the section
10311      contents, the section relocs, and the BFD symbol table.  We
10312      must tell the rest of the code not to free up this
10313      information.  It would be possible to instead create a table
10314      of changes which have to be made, as is done in coff-mips.c;
10315      that would be more work, but would require less memory when
10316      the linker is run.  */
10317
10318   if (N32_OP6 (re_insn) == N32_OP6_BR1
10319       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10320     {
10321       /* beqs     label    ; 15_PCREL */
10322       bfd_putb32 (re_insn, contents + em_irel->r_offset);
10323       reloc = R_NDS32_15_PCREL_RELA;
10324       cond_removed = 1;
10325     }
10326   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10327            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10328     {
10329       /* beqz     label ; 17_PCREL */
10330       bfd_putb32 (re_insn, contents + em_irel->r_offset);
10331       reloc = R_NDS32_17_PCREL_RELA;
10332       cond_removed = 1;
10333     }
10334   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10335            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10336     {
10337       /* Relax to one of the following 2 variations
10338
10339          case 2-4;  1st insn convertible, 16-bit on.
10340          bnes38  rt, ra, .L1    ; LONGJUMP5/9_PCREL/INSN16
10341          j       label          ; 25_PCREL/INSN16
10342          $1:
10343
10344          case 4-4; 1st insn not convertible
10345          bne  rt, ra, .L1       ; LONGJUMP5/15_PCREL/INSN16
10346          j    label             ; 25_PCREL/INSN16
10347          .L1:  */
10348
10349       /* Use j label as second instruction.  */
10350       insn = INSN_J;
10351       reloc = R_NDS32_25_PCREL_RELA;
10352       bfd_putb32 (insn, contents + em_irel->r_offset);
10353     }
10354   else
10355     return FALSE;
10356
10357   /* Set all relocations.  */
10358   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10359
10360   cond_irel =
10361     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10362                                  R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10363   cond_irel->r_addend = 1;
10364
10365   /* Use INSN16 of first branch instruction to distinguish if keeping
10366      INSN16 of final instruction or not.  */
10367   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10368                                            R_NDS32_INSN16, irel->r_offset);
10369   if (insn_irel == irelend)
10370     {
10371       /* Clean the final INSN16.  */
10372       insn_irel =
10373         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10374                                      R_NDS32_INSN16, em_irel->r_offset);
10375       insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10376                                         R_NDS32_NONE);
10377     }
10378
10379   if (cond_removed == 1)
10380     {
10381       *insn_len = 0;
10382
10383       /* Clear relocations.  */
10384       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10385
10386       for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10387         {
10388           cond_irel =
10389             find_relocs_at_address_addr (irel, internal_relocs, irelend,
10390                                          checked_types[i], laddr);
10391           if (cond_irel != irelend)
10392             {
10393               if (*seq_len == 0
10394                   && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10395                 {
10396                   /* If the branch instruction is 2 byte, it cannot remove
10397                      directly.  Only convert it to nop16 and remove it after
10398                      checking alignment issue.  */
10399                   insn16 = NDS32_NOP16;
10400                   bfd_putb16 (insn16, contents + laddr);
10401                   cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10402                 }
10403               else
10404                 cond_irel->r_info =
10405                   ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10406             }
10407         }
10408     }
10409   else
10410     {
10411       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10412                                    R_NDS32_LONGJUMP5);
10413     }
10414
10415   return TRUE;
10416 }
10417
10418 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section.  */
10419
10420 static bfd_boolean
10421 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10422                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10423                            int *seq_len, bfd_byte *contents,
10424                            Elf_Internal_Sym *isymbuf,
10425                            Elf_Internal_Shdr *symtab_hdr)
10426 {
10427   /* There are 2 variations for LONGJUMP5
10428      case 2-4;  1st insn convertible, 16-bit on.
10429      movi55  ta, imm11          ; LONGJUMP7/INSN16
10430      beq     rt, ta, label      ; 15_PCREL
10431
10432      case 4-4; 1st insn not convertible
10433      movi55  ta, imm11          ; LONGJUMP7/INSN16
10434      beq     rt, ta, label      ; 15_PCREL  */
10435
10436   bfd_vma laddr;
10437   Elf_Internal_Rela *cond_irel,  *irelend, *insn_irel;
10438   int pic_ext_target = 0;
10439   bfd_signed_vma foff;
10440   uint32_t insn, re_insn = 0;
10441   uint16_t insn16;
10442   uint32_t imm11;
10443
10444   irelend = internal_relocs + sec->reloc_count;
10445   laddr = irel->r_offset;
10446
10447   /* Get the reloc for the address from which the register is
10448      being loaded.  This reloc will tell us which function is
10449      actually being called.  */
10450
10451   cond_irel =
10452     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10453                                  R_NDS32_15_PCREL_RELA, irel->r_addend);
10454   if (cond_irel == irelend)
10455     {
10456       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
10457                           irel->r_offset);
10458       return FALSE;
10459     }
10460
10461   /* Get the value of the symbol referred to by the reloc.  */
10462   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10463                            &pic_ext_target);
10464
10465   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10466       || foff >= CONSERVATIVE_8BIT_S1)
10467     return FALSE;
10468
10469   /* Get the first instruction for its size.  */
10470   insn = bfd_getb32 (contents + laddr);
10471   if (insn & 0x80000000)
10472     {
10473       *seq_len = 0;
10474       /* Get the immediate from movi55.  */
10475       imm11 = N16_IMM5S (insn >> 16);
10476     }
10477   else
10478     {
10479       /* Get the immediate from movi.  */
10480       imm11 = N32_IMM20S (insn);
10481     }
10482
10483   /* Get the branch instruction.  */
10484   insn = bfd_getb32 (contents + irel->r_addend);
10485   /* Convert instruction to BR3.  */
10486   if ((insn >> 14) & 0x1)
10487     re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10488   else
10489     re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10490
10491   bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10492
10493   /* Set all relocations.  */
10494   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10495                                     R_NDS32_WORD_9_PCREL_RELA);
10496
10497   /* Clean relocations.  */
10498   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10499   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10500                                            R_NDS32_INSN16, irel->r_offset);
10501   if (insn_irel != irelend)
10502     {
10503       if (*seq_len == 0)
10504         {
10505           /* If the first insntruction is 16bit, convert it to nop16.  */
10506           insn16 = NDS32_NOP16;
10507           bfd_putb16 (insn16, contents + laddr);
10508           insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10509         }
10510       else
10511         cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10512                                           R_NDS32_NONE);
10513     }
10514   *insn_len = 0;
10515
10516   return TRUE;
10517 }
10518
10519 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10520
10521 /* Relax LOADSTORE relocation for nds32_elf_relax_section.  */
10522
10523 static bfd_boolean
10524 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10525                            asection *sec, Elf_Internal_Rela *irel,
10526                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10527                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10528                            Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10529 {
10530   int eliminate_sethi = 0, range_type;
10531   unsigned int i;
10532   bfd_vma local_sda, laddr;
10533   int seq_len;  /* Original length of instruction sequence.  */
10534   uint32_t insn;
10535   Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10536   bfd_vma access_addr = 0;
10537   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
10538   enum elf_nds32_reloc_type checked_types[] =
10539     { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10540       R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10541       R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10542       R_NDS32_TLS_LE_HI20
10543     };
10544
10545   irelend = internal_relocs + sec->reloc_count;
10546   seq_len = GET_SEQ_LEN (irel->r_addend);
10547   laddr = irel->r_offset;
10548   *insn_len = seq_len;
10549
10550   /* Get the high part relocation.  */
10551   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10552     {
10553       hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10554                                                checked_types[i], laddr);
10555       if (hi_irelfn != irelend)
10556         break;
10557     }
10558
10559   if (hi_irelfn == irelend)
10560     {
10561       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
10562                           irel->r_offset);
10563         return FALSE;
10564     }
10565
10566   range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10567   nds32_elf_final_sda_base (sec->output_section->owner,
10568                             link_info, &local_sda, FALSE);
10569
10570   switch (ELF32_R_TYPE (hi_irelfn->r_info))
10571     {
10572     case R_NDS32_HI20_RELA:
10573       insn = bfd_getb32 (contents + laddr);
10574       access_addr =
10575         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10576
10577       if (range_type == NDS32_LOADSTORE_IMM)
10578         {
10579           struct elf_link_hash_entry *h = NULL;
10580           int indx;
10581
10582           if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10583             {
10584               indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10585               h = elf_sym_hashes (abfd)[indx];
10586             }
10587
10588           if ((access_addr < CONSERVATIVE_20BIT)
10589               && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10590             {
10591               eliminate_sethi = 1;
10592               break;
10593             }
10594
10595           /* This is avoid to relax symbol address which is fixed
10596              relocations.  Ex: _stack.  */
10597           if (h && bfd_is_abs_section (h->root.u.def.section))
10598             return FALSE;
10599         }
10600
10601       if (!load_store_relax)
10602         return FALSE;
10603
10604       /* Case for set gp register.  */
10605       if (N32_RT5 (insn) == REG_GP)
10606         break;
10607
10608       if (range_type == NDS32_LOADSTORE_FLOAT_S
10609           || range_type == NDS32_LOADSTORE_FLOAT_D)
10610         {
10611           range_l = sdata_range[0][0];
10612           range_h = sdata_range[0][1];
10613         }
10614       else
10615         {
10616           range_l = sdata_range[1][0];
10617           range_h = sdata_range[1][1];
10618         }
10619       break;
10620
10621     case R_NDS32_GOT_HI20:
10622       access_addr =
10623         calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10624
10625       /* If this symbol is not in .got, the return value will be -1.
10626          Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10627          a negative offset is allowed.  */
10628       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10629           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10630         eliminate_sethi = 1;
10631       break;
10632
10633     case R_NDS32_PLT_GOTREL_HI20:
10634       access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10635                                                   hi_irelfn, symtab_hdr);
10636
10637       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10638           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10639         eliminate_sethi = 1;
10640       break;
10641
10642     case R_NDS32_GOTOFF_HI20:
10643       access_addr =
10644         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10645
10646       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10647           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10648         eliminate_sethi = 1;
10649       break;
10650
10651     case R_NDS32_GOTPC_HI20:
10652       /* The access_addr must consider r_addend of hi_irel.  */
10653       access_addr = sec->output_section->vma + sec->output_offset
10654         + irel->r_offset + hi_irelfn->r_addend;
10655
10656       if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10657           && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10658         eliminate_sethi = 1;
10659       break;
10660
10661     case R_NDS32_TLS_LE_HI20:
10662       access_addr =
10663         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10664       BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10665       access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10666       if ((range_type == NDS32_LOADSTORE_IMM)
10667           && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10668           && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10669         eliminate_sethi = 1;
10670       break;
10671
10672     default:
10673       return FALSE;
10674     }
10675
10676   /* Delete sethi instruction.  */
10677   if (eliminate_sethi == 1
10678       || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10679       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10680     {
10681       hi_irelfn->r_info =
10682         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10683       irel->r_info =
10684         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10685       *insn_len = 0;
10686     }
10687   return TRUE;
10688 }
10689
10690 /* Relax LO12 relocation for nds32_elf_relax_section.  */
10691
10692 static void
10693 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10694                       asection *sec, Elf_Internal_Rela *irel,
10695                       Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10696                       Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10697 {
10698   uint32_t insn;
10699   bfd_vma local_sda, laddr;
10700   unsigned long reloc;
10701   bfd_vma access_addr;
10702   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
10703   Elf_Internal_Rela *irelfn = NULL, *irelend;
10704   struct elf_link_hash_entry *h = NULL;
10705   int indx;
10706
10707   /* For SDA base relative relaxation.  */
10708   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10709                             &local_sda, FALSE);
10710
10711   irelend = internal_relocs + sec->reloc_count;
10712   laddr = irel->r_offset;
10713   insn = bfd_getb32 (contents + laddr);
10714
10715   if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10716     return;
10717
10718   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10719
10720   if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10721     {
10722       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10723       h = elf_sym_hashes (abfd)[indx];
10724     }
10725
10726   if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10727       && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10728     {
10729       reloc = R_NDS32_20_RELA;
10730       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10731       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10732       bfd_putb32 (insn, contents + laddr);
10733     }
10734   /* This is avoid to relax symbol address which is fixed
10735      relocations.  Ex: _stack.  */
10736   else if (N32_OP6 (insn) == N32_OP6_ORI
10737            && h && bfd_is_abs_section (h->root.u.def.section))
10738     return;
10739   else
10740     {
10741       range_l = sdata_range[1][0];
10742       range_h = sdata_range[1][1];
10743       switch (ELF32_R_TYPE (irel->r_info))
10744         {
10745         case R_NDS32_LO12S0_RELA:
10746           reloc = R_NDS32_SDA19S0_RELA;
10747           break;
10748         case R_NDS32_LO12S1_RELA:
10749           reloc = R_NDS32_SDA18S1_RELA;
10750           break;
10751         case R_NDS32_LO12S2_RELA:
10752           reloc = R_NDS32_SDA17S2_RELA;
10753           break;
10754         case R_NDS32_LO12S2_DP_RELA:
10755           range_l = sdata_range[0][0];
10756           range_h = sdata_range[0][1];
10757           reloc = R_NDS32_SDA12S2_DP_RELA;
10758           break;
10759         case R_NDS32_LO12S2_SP_RELA:
10760           range_l = sdata_range[0][0];
10761           range_h = sdata_range[0][1];
10762           reloc = R_NDS32_SDA12S2_SP_RELA;
10763           break;
10764         default:
10765           return;
10766         }
10767
10768       /* There are range_h and range_l because linker has to promise
10769          all sections move cross one page together.  */
10770       if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
10771           || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10772         {
10773           if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
10774             {
10775               /* Maybe we should add R_NDS32_INSN16 reloc type here
10776                  or manually do some optimization.  sethi can't be
10777                  eliminated when updating $gp so the relative ori
10778                  needs to be preserved.  */
10779               return;
10780             }
10781           if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
10782                                         &insn))
10783             return;
10784           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10785           bfd_putb32 (insn, contents + laddr);
10786
10787           irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
10788                                            R_NDS32_INSN16);
10789           /* SDA17 must keep INSN16 for converting fp_as_gp.  */
10790           if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
10791             irelfn->r_info =
10792               ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
10793
10794         }
10795     }
10796   return;
10797 }
10798
10799 /* Relax low part of PIC instruction pattern.  */
10800
10801 static void
10802 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
10803                          asection *sec, Elf_Internal_Rela *irel,
10804                          bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10805                          Elf_Internal_Shdr *symtab_hdr)
10806 {
10807   uint32_t insn;
10808   bfd_vma local_sda, laddr;
10809   bfd_signed_vma foff;
10810   unsigned long reloc;
10811
10812   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10813                             &local_sda, FALSE);
10814   laddr = irel->r_offset;
10815   insn = bfd_getb32 (contents + laddr);
10816
10817   if (N32_OP6 (insn) != N32_OP6_ORI)
10818     return;
10819
10820   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
10821     {
10822       foff = calculate_got_memory_address (abfd, link_info, irel,
10823                                            symtab_hdr) - local_sda;
10824       reloc = R_NDS32_GOT20;
10825     }
10826   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
10827     {
10828       foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
10829                                            symtab_hdr) - local_sda;
10830       reloc = R_NDS32_PLT_GOTREL_LO20;
10831     }
10832   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
10833     {
10834       foff = calculate_memory_address (abfd, irel, isymbuf,
10835                                        symtab_hdr) - local_sda;
10836       reloc = R_NDS32_GOTOFF;
10837     }
10838   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
10839     {
10840       foff = local_sda - sec->output_section->vma + sec->output_offset
10841         + irel->r_offset + irel->r_addend;
10842       reloc = R_NDS32_GOTPC20;
10843     }
10844   else
10845     return;
10846
10847   if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
10848     {
10849       /* Turn into MOVI.  */
10850       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10851       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10852       bfd_putb32 (insn, contents + laddr);
10853     }
10854 }
10855
10856 /* Relax low part of LE TLS instruction pattern.  */
10857
10858 static void
10859 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
10860                            Elf_Internal_Rela *irel,
10861                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10862                            Elf_Internal_Shdr *symtab_hdr)
10863 {
10864   uint32_t insn;
10865   bfd_vma laddr;
10866   bfd_signed_vma foff;
10867   unsigned long reloc;
10868
10869   laddr = irel->r_offset;
10870   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10871   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10872   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10873   insn = bfd_getb32 (contents + laddr);
10874
10875   if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
10876       && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
10877     {
10878       /* Pattern sethi-ori transform to movi.  */
10879       reloc = R_NDS32_TLS_LE_20;
10880       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10881       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10882       bfd_putb32 (insn, contents + laddr);
10883     }
10884 }
10885
10886 /* Relax LE TLS calculate address instruction pattern.  */
10887
10888 static void
10889 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
10890                           asection *sec, Elf_Internal_Rela *irel,
10891                           Elf_Internal_Rela *internal_relocs,
10892                           bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10893                           Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
10894 {
10895   /* Local TLS non-pic
10896      sethi    ta, hi20(symbol@tpoff)      ; TLS_LE_HI20
10897      ori      ta, ta, lo12(symbol@tpoff)  ; TLS_LE_LO12
10898      add      ra, ta, tp                  ; TLS_LE_ADD */
10899
10900   uint32_t insn;
10901   bfd_vma laddr;
10902   bfd_signed_vma foff;
10903   Elf_Internal_Rela *i1_irelfn, *irelend;
10904
10905   irelend = internal_relocs + sec->reloc_count;
10906   laddr = irel->r_offset;
10907   insn = bfd_getb32 (contents + laddr);
10908   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
10909                                       R_NDS32_PTR_RESOLVED);
10910   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10911   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10912   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10913
10914   /* The range is +/-16k.  */
10915   if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
10916       && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
10917     {
10918       /* Transform add to addi.  */
10919       insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
10920       irel->r_info =
10921         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
10922
10923       bfd_putb32 (insn, contents + laddr);
10924       if (i1_irelfn != irelend)
10925         {
10926           i1_irelfn->r_addend |= 1;
10927           *again = TRUE;
10928         }
10929     }
10930 }
10931
10932 /* Relax LE TLS load store instruction pattern.  */
10933
10934 static void
10935 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
10936                          asection *sec, Elf_Internal_Rela *irel,
10937                          Elf_Internal_Rela *internal_relocs,
10938                          bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10939                          Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
10940 {
10941
10942   uint32_t insn;
10943   bfd_vma laddr;
10944   bfd_signed_vma foff;
10945   Elf_Internal_Rela *i1_irelfn, *irelend;
10946   int success = 0;
10947
10948   irelend = internal_relocs + sec->reloc_count;
10949   laddr = irel->r_offset;
10950   insn = bfd_getb32 (contents + laddr);
10951   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
10952                                       R_NDS32_PTR_RESOLVED);
10953   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10954   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10955   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10956
10957   switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
10958     {
10959     case (N32_OP6_MEM << 8) | N32_MEM_LB:
10960     case (N32_OP6_MEM << 8) | N32_MEM_SB:
10961     case (N32_OP6_MEM << 8) | N32_MEM_LBS:
10962       /* The range is +/-16k.  */
10963       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
10964           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
10965         {
10966           insn =
10967             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
10968           irel->r_info =
10969             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
10970           success = 1;
10971           break;
10972         }
10973       /* Fall through.  */
10974     case (N32_OP6_MEM << 8) | N32_MEM_LH:
10975     case (N32_OP6_MEM << 8) | N32_MEM_SH:
10976     case (N32_OP6_MEM << 8) | N32_MEM_LHS:
10977       /* The range is +/-32k.  */
10978       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
10979           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
10980         {
10981           insn =
10982             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
10983           irel->r_info =
10984             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
10985           success = 1;
10986           break;
10987         }
10988       /* Fall through.  */
10989     case (N32_OP6_MEM << 8) | N32_MEM_LW:
10990     case (N32_OP6_MEM << 8) | N32_MEM_SW:
10991       /* The range is +/-64k.  */
10992       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
10993           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
10994         {
10995           insn =
10996             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
10997           irel->r_info =
10998             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
10999           success = 1;
11000           break;
11001         }
11002       /* Fall through.  */
11003     default:
11004       break;
11005     }
11006
11007   if (success)
11008     {
11009       bfd_putb32 (insn, contents + laddr);
11010       if (i1_irelfn != irelend)
11011         {
11012           i1_irelfn->r_addend |= 1;
11013           *again = TRUE;
11014         }
11015     }
11016 }
11017
11018 /* Relax PTR relocation for nds32_elf_relax_section.  */
11019
11020 static bfd_boolean
11021 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11022                      Elf_Internal_Rela *internal_relocs, int *insn_len,
11023                      int *seq_len, bfd_byte *contents)
11024 {
11025   Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11026
11027   irelend = internal_relocs + sec->reloc_count;
11028
11029   re_irel =
11030     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11031                                  R_NDS32_PTR_RESOLVED, irel->r_addend);
11032
11033   if (re_irel == irelend)
11034     {
11035       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11036                           irel->r_offset);
11037       return FALSE;
11038     }
11039
11040   if (re_irel->r_addend != 1)
11041     return FALSE;
11042
11043   /* Pointed target is relaxed and no longer needs this void *,
11044      change the type to NONE.  */
11045   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11046
11047   /* Find PTR_COUNT to decide remove it or not.  If PTR_COUNT does
11048      not exist, it means only count 1 and remove it directly.  */
11049   /* TODO: I hope we can obsolate R_NDS32_COUNT in the future.  */
11050   count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11051                                        R_NDS32_PTR_COUNT);
11052   ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11053                                      R_NDS32_PTR);
11054   if (count_irel != irelend)
11055     {
11056       if (--count_irel->r_addend > 0)
11057         return FALSE;
11058     }
11059
11060   if (ptr_irel != irelend)
11061     return FALSE;
11062
11063   /* If the PTR_COUNT is already 0, remove current instruction.  */
11064   *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11065   *insn_len = 0;
11066   return TRUE;
11067 }
11068
11069 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section.  */
11070
11071 static void
11072 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11073                              asection *sec, Elf_Internal_Rela *irel,
11074                              Elf_Internal_Rela *internal_relocs,
11075                              bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11076                              Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11077 {
11078   uint32_t insn;
11079   bfd_signed_vma foff;
11080   Elf_Internal_Rela *i1_irelfn, *irelend;
11081   bfd_vma local_sda, laddr;
11082
11083   irelend = internal_relocs + sec->reloc_count;
11084   laddr = irel->r_offset;
11085   insn = bfd_getb32 (contents + laddr);
11086
11087   /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11088      we need additional space.  It might be help if we could
11089      borrow some space from instructions to be eliminated
11090      such as sethi, ori, add.  */
11091   if (insn & 0x80000000)
11092     return;
11093
11094   if (nds32_elf_check_dup_relocs
11095       (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11096     return;
11097
11098   i1_irelfn =
11099     find_relocs_at_address (irel, internal_relocs, irelend,
11100                             R_NDS32_PTR_RESOLVED);
11101
11102   /* FIXIT 090606
11103      The boundary should be reduced since the .plt section hasn't
11104      been created and the address of specific entry is still unknown
11105      Maybe the range between the function call and the begin of the
11106      .text section can be used to decide if the .plt is in the range
11107      of function call.  */
11108
11109   if (N32_OP6 (insn) == N32_OP6_ALU1
11110       && N32_SUB5 (insn) == N32_ALU1_ADD)
11111     {
11112       /* Get the value of the symbol referred to by the reloc.  */
11113       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11114                                 &local_sda, FALSE);
11115       foff = (bfd_signed_vma) (calculate_plt_memory_address
11116                                (abfd, link_info, isymbuf, irel,
11117                                 symtab_hdr) - local_sda);
11118       /* This condition only happened when symbol is undefined.  */
11119       if (foff == 0)
11120         return;
11121
11122       if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11123         return;
11124       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11125                                    R_NDS32_PLT_GOTREL_LO19);
11126       /* addi.gp */
11127       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
11128     }
11129   else if (N32_OP6 (insn) == N32_OP6_JREG
11130            && N32_SUB5 (insn) == N32_JREG_JRAL)
11131     {
11132       /* Get the value of the symbol referred to by the reloc.  */
11133       foff =
11134         calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11135       /* This condition only happened when symbol is undefined.  */
11136       if (foff == 0)
11137         return;
11138       if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11139         return;
11140       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11141       insn = INSN_JAL;
11142     }
11143   else
11144     return;
11145
11146   bfd_putb32 (insn, contents + laddr);
11147   if (i1_irelfn != irelend)
11148     {
11149       i1_irelfn->r_addend |= 1;
11150       *again = TRUE;
11151     }
11152 }
11153
11154 /* Relax GOT_SUFF relocation for nds32_elf_relax_section.  */
11155
11156 static void
11157 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11158                           asection *sec, Elf_Internal_Rela *irel,
11159                           Elf_Internal_Rela *internal_relocs,
11160                           bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11161                           bfd_boolean *again)
11162 {
11163   uint32_t insn;
11164   bfd_signed_vma foff;
11165   Elf_Internal_Rela *i1_irelfn, *irelend;
11166   bfd_vma local_sda, laddr;
11167
11168   irelend = internal_relocs + sec->reloc_count;
11169   laddr = irel->r_offset;
11170   insn = bfd_getb32 (contents + laddr);
11171   if (insn & 0x80000000)
11172     return;
11173
11174   if (nds32_elf_check_dup_relocs
11175       (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11176     return;
11177
11178   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11179                                       R_NDS32_PTR_RESOLVED);
11180
11181   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11182                             &local_sda, FALSE);
11183   foff = calculate_got_memory_address (abfd, link_info, irel,
11184                                        symtab_hdr) - local_sda;
11185
11186   if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11187     {
11188       /* Turn LW to LWI.GP.  Change relocation type to R_NDS32_GOT_REL.  */
11189       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11190       irel->r_info =
11191         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11192       bfd_putb32 (insn, contents + laddr);
11193       if (i1_irelfn != irelend)
11194         {
11195           i1_irelfn->r_addend |= 1;
11196           *again = TRUE;
11197         }
11198     }
11199 }
11200
11201 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section.  */
11202
11203 static void
11204 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11205                              asection *sec, Elf_Internal_Rela *irel,
11206                              Elf_Internal_Rela *internal_relocs,
11207                              bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11208                              Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11209 {
11210   int opc_insn_gotoff;
11211   uint32_t insn;
11212   bfd_signed_vma foff;
11213   Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11214   bfd_vma local_sda, laddr;
11215
11216   irelend = internal_relocs + sec->reloc_count;
11217   laddr = irel->r_offset;
11218   insn = bfd_getb32 (contents + laddr);
11219
11220   if (insn & 0x80000000)
11221     return;
11222
11223   if (nds32_elf_check_dup_relocs
11224       (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11225     return;
11226
11227   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11228                                       R_NDS32_PTR_RESOLVED);
11229   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11230                             &local_sda, FALSE);
11231   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11232   foff = foff - local_sda;
11233
11234   if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11235     return;
11236
11237   /* Concatenate opcode and sub-opcode for switch case.
11238      It may be MEM or ALU1.  */
11239   opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11240   switch (opc_insn_gotoff)
11241     {
11242     case (N32_OP6_MEM << 8) | N32_MEM_LW:
11243       /* 4-byte aligned.  */
11244       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11245       irel->r_info =
11246         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11247       break;
11248     case (N32_OP6_MEM << 8) | N32_MEM_SW:
11249       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11250       irel->r_info =
11251         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11252       break;
11253     case (N32_OP6_MEM << 8) | N32_MEM_LH:
11254       /* 2-byte aligned.  */
11255       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11256       irel->r_info =
11257         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11258       break;
11259     case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11260       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
11261       irel->r_info =
11262         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11263       break;
11264     case (N32_OP6_MEM << 8) | N32_MEM_SH:
11265       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
11266       irel->r_info =
11267         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11268       break;
11269     case (N32_OP6_MEM << 8) | N32_MEM_LB:
11270       /* 1-byte aligned.  */
11271       insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11272       irel->r_info =
11273         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11274       break;
11275     case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11276       insn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
11277       irel->r_info =
11278         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11279       break;
11280     case (N32_OP6_MEM << 8) | N32_MEM_SB:
11281       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11282       irel->r_info =
11283         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11284       break;
11285     case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11286       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
11287       irel->r_info =
11288         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11289       break;
11290     default:
11291       return;
11292     }
11293
11294   bfd_putb32 (insn, contents + laddr);
11295   if (i1_irelfn != irelend)
11296     {
11297       i1_irelfn->r_addend |= 1;
11298       *again = TRUE;
11299     }
11300   if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11301                                            R_NDS32_INSN16)) != irelend)
11302     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11303
11304 }
11305
11306 static bfd_boolean
11307 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11308                           Elf_Internal_Rela *internal_relocs,
11309                           bfd_byte *contents,
11310                           nds32_elf_blank_t **relax_blank_list,
11311                           int optimize, int opt_size)
11312 {
11313   /* This code block is used to adjust 4-byte alignment by relax a pair
11314      of instruction a time.
11315
11316      It recognizes three types of relocations.
11317      1. R_NDS32_LABEL - a alignment.
11318      2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11319      3. is_16bit_NOP () - remove a 16-bit instruction.  */
11320
11321   /* TODO: It seems currently implementation only support 4-byte alignment.
11322      We should handle any-alignment.  */
11323
11324   Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11325   Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11326   Elf_Internal_Rela rel_temp;
11327   Elf_Internal_Rela *irelend;
11328   bfd_vma address;
11329   uint16_t insn16;
11330
11331   /* Checking for branch relaxation relies on the relocations to
11332      be sorted on 'r_offset'.  This is not guaranteed so we must sort.  */
11333   nds32_insertion_sort (internal_relocs, sec->reloc_count,
11334                         sizeof (Elf_Internal_Rela), compar_reloc);
11335
11336   irelend = internal_relocs + sec->reloc_count;
11337
11338   /* Force R_NDS32_LABEL before R_NDS32_INSN16.  */
11339   /* FIXME: Can we generate the right order in assembler?
11340      So we don't have to swapping them here.  */
11341
11342   for (label_rel = internal_relocs, insn_rel = internal_relocs;
11343        label_rel < irelend; label_rel++)
11344     {
11345       if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11346         continue;
11347
11348       /* Find the first reloc has the same offset with label_rel.  */
11349       while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11350         insn_rel++;
11351
11352       for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11353            insn_rel++)
11354         /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11355            address.  */
11356         if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11357           break;
11358
11359       if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11360           && insn_rel < label_rel)
11361         {
11362           /* Swap the two reloc if the R_NDS32_INSN16 is
11363              before R_NDS32_LABEL.  */
11364           memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11365           memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11366           memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11367         }
11368     }
11369
11370   label_rel = NULL;
11371   insn_rel = NULL;
11372   /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11373      or higher, remove other R_NDS32_LABEL with lower alignment.
11374      If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11375      then the R_NDS32_LABEL sequence is broke.  */
11376   for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11377     {
11378       if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11379         {
11380           if (label_rel == NULL)
11381             {
11382               if (tmp_rel->r_addend < 2)
11383                 label_rel = tmp_rel;
11384               continue;
11385             }
11386           else if (tmp_rel->r_addend > 1)
11387             {
11388               /* Remove all LABEL relocation from label_rel to tmp_rel
11389                  including relocations with same offset as tmp_rel.  */
11390               for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11391                    || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11392                 {
11393                   if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11394                       && tmp2_rel->r_addend < 2)
11395                     tmp2_rel->r_info =
11396                       ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11397                                     R_NDS32_NONE);
11398                 }
11399               label_rel = NULL;
11400             }
11401         }
11402       else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11403         {
11404           /* A new INSN16 which can be converted, so clear label_rel.  */
11405           if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11406                                    irelend, &insn16)
11407               || is_16bit_NOP (abfd, sec, tmp_rel))
11408             label_rel = NULL;
11409         }
11410     }
11411
11412   label_rel = NULL;
11413   insn_rel = NULL;
11414   /* Optimized for speed and nothing has not been relaxed.
11415      It's time to align labels.
11416      We may convert a 16-bit instruction right before a label to
11417      32-bit, in order to align the label if necessary
11418      all reloc entries has been sorted by r_offset.  */
11419   for (irel = internal_relocs; irel < irelend; irel++)
11420     {
11421       if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11422           && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11423         continue;
11424
11425       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11426         {
11427           /* A new INSN16 found, resize the old one.  */
11428           if (is_convert_32_to_16
11429               (abfd, sec, irel, internal_relocs, irelend, &insn16)
11430               || is_16bit_NOP (abfd, sec, irel))
11431             {
11432               if (insn_rel)
11433                 {
11434                   /* Previous INSN16 reloc exists, reduce its
11435                      size to 16-bit.  */
11436                   if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11437                                            irelend, &insn16))
11438                     {
11439                       nds32_elf_write_16 (abfd, contents, insn_rel,
11440                                           internal_relocs, irelend, insn16);
11441
11442                       if (!insert_nds32_elf_blank_recalc_total
11443                           (relax_blank_list, insn_rel->r_offset + 2, 2))
11444                         return FALSE;
11445                     }
11446                   else if (is_16bit_NOP (abfd, sec, insn_rel))
11447                     {
11448                       if (!insert_nds32_elf_blank_recalc_total
11449                           (relax_blank_list, insn_rel->r_offset, 2))
11450                         return FALSE;
11451                     }
11452                   insn_rel->r_info =
11453                     ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11454                 }
11455               /* Save the new one for later use.  */
11456               insn_rel = irel;
11457             }
11458           else
11459             irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11460                                          R_NDS32_NONE);
11461         }
11462       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11463         {
11464           /* Search for label.  */
11465           int force_relax = 0;
11466
11467           /* Label on 16-bit instruction or optimization
11468              needless, just reset this reloc.  */
11469           insn16 = bfd_getb16 (contents + irel->r_offset);
11470           if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11471             {
11472               irel->r_info =
11473                 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11474               continue;
11475             }
11476
11477           address =
11478             irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11479                                                         irel->r_offset, 1);
11480
11481           if (!insn_rel)
11482             {
11483               /* Check if there is case which can not be aligned.  */
11484               if (irel->r_addend == 2 && address & 0x2)
11485                 return FALSE;
11486               continue;
11487             }
11488
11489           /* Try to align this label.  */
11490
11491           if ((irel->r_addend & 0x1f) < 2)
11492             {
11493               /* Check if there is a INSN16 at the same address.
11494                  Label_rel always seats before insn_rel after
11495                  our sort.  */
11496
11497               /* Search for INSN16 at LABEL location.  If INSN16 is at
11498                  same location and this LABEL alignment is lower than 2,
11499                  the INSN16 can be converted to 2-byte.  */
11500               for (tmp_rel = irel;
11501                    tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11502                    tmp_rel++)
11503                 {
11504                   if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11505                       && (is_convert_32_to_16
11506                           (abfd, sec, tmp_rel, internal_relocs,
11507                            irelend, &insn16)
11508                           || is_16bit_NOP (abfd, sec, tmp_rel)))
11509                     {
11510                       force_relax = 1;
11511                       break;
11512                     }
11513                 }
11514             }
11515
11516           if (force_relax || irel->r_addend == 1 || address & 0x2)
11517             {
11518               /* Label not aligned.  */
11519               /* Previous reloc exists, reduce its size to 16-bit.  */
11520               if (is_convert_32_to_16 (abfd, sec, insn_rel,
11521                                        internal_relocs, irelend, &insn16))
11522                 {
11523                   nds32_elf_write_16 (abfd, contents, insn_rel,
11524                                       internal_relocs, irelend, insn16);
11525
11526                   if (!insert_nds32_elf_blank_recalc_total
11527                       (relax_blank_list, insn_rel->r_offset + 2, 2))
11528                     return FALSE;
11529                 }
11530               else if (is_16bit_NOP (abfd, sec, insn_rel))
11531                 {
11532                   if (!insert_nds32_elf_blank_recalc_total
11533                       (relax_blank_list, insn_rel->r_offset, 2))
11534                     return FALSE;
11535                 }
11536
11537             }
11538           /* INSN16 reloc is used.  */
11539           insn_rel = NULL;
11540         }
11541     }
11542
11543   address =
11544     sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11545   if (insn_rel && (address & 0x2 || opt_size))
11546     {
11547       if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11548                                irelend, &insn16))
11549         {
11550           nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11551                               irelend, insn16);
11552           if (!insert_nds32_elf_blank_recalc_total
11553               (relax_blank_list, insn_rel->r_offset + 2, 2))
11554             return FALSE;
11555           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11556                                            R_NDS32_NONE);
11557         }
11558       else if (is_16bit_NOP (abfd, sec, insn_rel))
11559         {
11560           if (!insert_nds32_elf_blank_recalc_total
11561               (relax_blank_list, insn_rel->r_offset, 2))
11562             return FALSE;
11563           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11564                                            R_NDS32_NONE);
11565         }
11566     }
11567   insn_rel = NULL;
11568   return TRUE;
11569 }
11570
11571 /* Pick relaxation round.  */
11572
11573 static int
11574 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11575                       struct elf_nds32_link_hash_table *table,
11576                       struct bfd_link_info *link_info)
11577 {
11578   static asection *final_sec, *first_sec = NULL;
11579   static bfd_boolean normal_again = FALSE;
11580   static bfd_boolean set = FALSE;
11581   static bfd_boolean first = TRUE;
11582   int round_table[] = {
11583       NDS32_RELAX_NORMAL_ROUND,
11584       NDS32_RELAX_JUMP_IFC_ROUND,
11585       NDS32_RELAX_EX9_BUILD_ROUND,
11586       NDS32_RELAX_EX9_REPLACE_ROUND,
11587   };
11588   static int pass = 0;
11589   static int relax_round;
11590
11591   /* The new round.  */
11592   if (init && first_sec == sec)
11593     {
11594       set = TRUE;
11595       normal_again = FALSE;
11596     }
11597
11598   if (first)
11599     {
11600       /* Run an empty run to get the final section.  */
11601       relax_round = NDS32_RELAX_EMPTY_ROUND;
11602
11603       /* It has to enter relax again because we can
11604          not make sure what the final turn is.  */
11605       *again = TRUE;
11606
11607       first = FALSE;
11608       first_sec = sec;
11609     }
11610
11611   if (!set)
11612     {
11613       /* Not reenter yet.  */
11614       final_sec = sec;
11615       return relax_round;
11616     }
11617
11618   relax_round = round_table[pass];
11619
11620   if (!init && relax_round == NDS32_RELAX_NORMAL_ROUND && *again)
11621     normal_again = TRUE;
11622
11623   if (!init && final_sec == sec)
11624     {
11625       switch (relax_round)
11626         {
11627         case NDS32_RELAX_NORMAL_ROUND:
11628           if (!normal_again)
11629             {
11630               /* Normal relaxation done.  */
11631               if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11632                 {
11633                   pass++;
11634                   *again = TRUE;
11635                 }
11636               else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11637                 {
11638                   pass += 2;    /* NDS32_RELAX_EX9_BUILD_ROUND */
11639                   *again = TRUE;
11640                 }
11641               else if (table->ex9_import_file)
11642                 {
11643                   /* Import ex9 table.  */
11644                   if (table->update_ex9_table)
11645                     pass += 2;  /* NDS32_RELAX_EX9_BUILD_ROUND */
11646                   else
11647                     pass += 3;  /* NDS32_RELAX_EX9_REPLACE_ROUND */
11648                   nds32_elf_ex9_import_table (link_info);
11649                   *again = TRUE;
11650                 }
11651             }
11652           break;
11653         case NDS32_RELAX_JUMP_IFC_ROUND:
11654           if (!nds32_elf_ifc_finish (link_info))
11655             _bfd_error_handler (_("error: Jump IFC Fail."));
11656           if (table->target_optimize & NDS32_RELAX_EX9_ON)
11657             {
11658               pass++;
11659               *again = TRUE;
11660             }
11661           break;
11662         case NDS32_RELAX_EX9_BUILD_ROUND:
11663           nds32_elf_ex9_finish (link_info);
11664           pass++;
11665           *again = TRUE;
11666           break;
11667         case NDS32_RELAX_EX9_REPLACE_ROUND:
11668           if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11669             {
11670               /* Do jump IFC optimization again.  */
11671               if (!nds32_elf_ifc_finish (link_info))
11672                 _bfd_error_handler (_("error: Jump IFC Fail."));
11673             }
11674           break;
11675         default:
11676           break;
11677         }
11678     }
11679
11680   return relax_round;
11681 }
11682
11683 static bfd_boolean
11684 nds32_elf_relax_section (bfd *abfd, asection *sec,
11685                          struct bfd_link_info *link_info, bfd_boolean *again)
11686 {
11687   nds32_elf_blank_t *relax_blank_list = NULL;
11688   Elf_Internal_Shdr *symtab_hdr;
11689   Elf_Internal_Rela *internal_relocs;
11690   Elf_Internal_Rela *irel;
11691   Elf_Internal_Rela *irelend;
11692   Elf_Internal_Sym *isymbuf = NULL;
11693   bfd_byte *contents = NULL;
11694   bfd_boolean result = TRUE;
11695   int optimize = 0;
11696   int opt_size = 0;
11697   uint32_t insn;
11698   uint16_t insn16;
11699
11700   /* Target dependnet option.  */
11701   struct elf_nds32_link_hash_table *table;
11702   int load_store_relax;
11703   int relax_round;
11704
11705   relax_blank_list = NULL;
11706
11707   *again = FALSE;
11708
11709   /* Nothing to do for
11710    * relocatable link or
11711    * non-relocatable section or
11712    * non-code section or
11713    * empty content or
11714    * no reloc entry.  */
11715   if (bfd_link_relocatable (link_info)
11716       || (sec->flags & SEC_RELOC) == 0
11717       || (sec->flags & SEC_EXCLUDE) != 0
11718       || (sec->flags & SEC_CODE) == 0
11719       || sec->size == 0)
11720     return TRUE;
11721
11722   /* 09.12.11 Workaround.  */
11723   /*  We have to adjust align for R_NDS32_LABEL if needed.
11724       The adjust approach only can fix 2-byte align once.  */
11725   if (sec->alignment_power > 2)
11726     return TRUE;
11727
11728   /* The optimization type to do.  */
11729
11730   table = nds32_elf_hash_table (link_info);
11731   relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11732   switch (relax_round)
11733     {
11734     case NDS32_RELAX_JUMP_IFC_ROUND:
11735       /* Here is the entrance of ifc jump relaxation.  */
11736       if (!nds32_elf_ifc_calc (link_info, abfd, sec))
11737         return FALSE;
11738       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11739       return TRUE;
11740
11741     case NDS32_RELAX_EX9_BUILD_ROUND:
11742       /* Here is the entrance of ex9 relaxation.  There are two pass of
11743          ex9 relaxation.  The one is to traverse all instructions and build
11744          the hash table.  The other one is to compare instructions and replace
11745          it by ex9.it.  */
11746       if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
11747         return FALSE;
11748       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11749       return TRUE;
11750
11751     case NDS32_RELAX_EX9_REPLACE_ROUND:
11752       if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
11753         return FALSE;
11754       return TRUE;
11755
11756     case NDS32_RELAX_EMPTY_ROUND:
11757       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11758       return TRUE;
11759
11760     case NDS32_RELAX_NORMAL_ROUND:
11761     default:
11762       if (sec->reloc_count == 0)
11763         return TRUE;
11764       break;
11765     }
11766
11767   /* The begining of general relaxation.  */
11768
11769   if (is_SDA_BASE_set == 0)
11770     {
11771       bfd_vma gp;
11772       is_SDA_BASE_set = 1;
11773       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11774                                 &gp, FALSE);
11775       relax_range_measurement (abfd);
11776     }
11777
11778   if (is_ITB_BASE_set == 0)
11779     {
11780       /* Set the _ITB_BASE_.  */
11781       if (!nds32_elf_ex9_itb_base (link_info))
11782         {
11783           _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"), abfd);
11784           bfd_set_error (bfd_error_bad_value);
11785         }
11786     }
11787
11788   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11789   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
11790   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11791                                                TRUE /* keep_memory */);
11792   if (internal_relocs == NULL)
11793     goto error_return;
11794
11795   irelend = internal_relocs + sec->reloc_count;
11796   irel = find_relocs_at_address (internal_relocs, internal_relocs,
11797                                  irelend, R_NDS32_RELAX_ENTRY);
11798
11799   if (irel == irelend)
11800     return TRUE;
11801
11802   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
11803     {
11804       if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
11805         {
11806           nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11807           return TRUE;
11808         }
11809
11810       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
11811         optimize = 1;
11812
11813       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
11814         opt_size = 1;
11815     }
11816
11817   load_store_relax = table->load_store_relax;
11818
11819   /* Get symbol table and section content.  */
11820   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
11821       || !nds32_get_local_syms (abfd, sec, &isymbuf))
11822     goto error_return;
11823
11824   /* Do relax loop only when finalize is not done.
11825      Take care of relaxable relocs except INSN16.  */
11826   for (irel = internal_relocs; irel < irelend; irel++)
11827     {
11828       int seq_len;              /* Original length of instruction sequence.  */
11829       int insn_len = 0;         /* Final length of instruction sequence.  */
11830       bfd_boolean removed;
11831
11832       insn = 0;
11833       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
11834           && (irel->r_addend & 0x1f) >= 2)
11835         optimize = 1;
11836
11837       /* Relocation Types
11838          R_NDS32_LONGCALL1      53
11839          R_NDS32_LONGCALL2      54
11840          R_NDS32_LONGCALL3      55
11841          R_NDS32_LONGJUMP1      56
11842          R_NDS32_LONGJUMP2      57
11843          R_NDS32_LONGJUMP3      58
11844          R_NDS32_LOADSTORE      59  */
11845       if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
11846           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
11847         seq_len = GET_SEQ_LEN (irel->r_addend);
11848
11849       /* Relocation Types
11850          R_NDS32_LONGCALL4      107
11851          R_NDS32_LONGCALL5      108
11852          R_NDS32_LONGCALL6      109
11853          R_NDS32_LONGJUMP4      110
11854          R_NDS32_LONGJUMP5      111
11855          R_NDS32_LONGJUMP6      112
11856          R_NDS32_LONGJUMP7      113  */
11857       else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
11858                && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
11859         seq_len = 4;
11860
11861         /* Relocation Types
11862          R_NDS32_LO12S0_RELA            30
11863          R_NDS32_LO12S1_RELA            29
11864          R_NDS32_LO12S2_RELA            28
11865          R_NDS32_LO12S2_SP_RELA         71
11866          R_NDS32_LO12S2_DP_RELA         70
11867          R_NDS32_GOT_LO12               46
11868          R_NDS32_GOTOFF_LO12            50
11869          R_NDS32_PLTREL_LO12            65
11870          R_NDS32_PLT_GOTREL_LO12        67
11871          R_NDS32_17IFC_PCREL_RELA       96
11872          R_NDS32_GOT_SUFF               193
11873          R_NDS32_GOTOFF_SUFF            194
11874          R_NDS32_PLT_GOT_SUFF           195
11875          R_NDS32_MULCALL_SUFF           196
11876          R_NDS32_PTR                    197  */
11877       else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
11878                 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
11879                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
11880                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
11881                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
11882                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
11883                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
11884                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
11885                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
11886                || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
11887                    && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
11888                || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
11889                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
11890                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
11891                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
11892         seq_len = 0;
11893       else
11894         continue;
11895
11896       insn_len = seq_len;
11897       removed = FALSE;
11898
11899       switch (ELF32_R_TYPE (irel->r_info))
11900         {
11901         case R_NDS32_LONGCALL1:
11902           removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
11903                                                &insn_len, contents, isymbuf,
11904                                                symtab_hdr);
11905           break;
11906         case R_NDS32_LONGCALL2:
11907           removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
11908                                                &insn_len, contents, isymbuf,
11909                                                symtab_hdr);
11910           break;
11911         case R_NDS32_LONGCALL3:
11912           removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
11913                                                &insn_len, contents, isymbuf,
11914                                                symtab_hdr);
11915           break;
11916         case R_NDS32_LONGJUMP1:
11917           removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
11918                                                &insn_len, contents, isymbuf,
11919                                                symtab_hdr);
11920           break;
11921         case R_NDS32_LONGJUMP2:
11922           removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
11923                                                &insn_len, contents, isymbuf,
11924                                                symtab_hdr);
11925           break;
11926         case R_NDS32_LONGJUMP3:
11927           removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
11928                                                &insn_len, contents, isymbuf,
11929                                                symtab_hdr);
11930           break;
11931         case R_NDS32_LONGCALL4:
11932           removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
11933                                                &insn_len, contents, isymbuf,
11934                                                symtab_hdr);
11935           break;
11936         case R_NDS32_LONGCALL5:
11937           removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
11938                                                &insn_len, contents, isymbuf,
11939                                                symtab_hdr);
11940           break;
11941         case R_NDS32_LONGCALL6:
11942           removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
11943                                                &insn_len, contents, isymbuf,
11944                                                symtab_hdr);
11945           break;
11946         case R_NDS32_LONGJUMP4:
11947           removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
11948                                                &insn_len, contents, isymbuf,
11949                                                symtab_hdr);
11950           break;
11951         case R_NDS32_LONGJUMP5:
11952           removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
11953                                                &insn_len, &seq_len, contents,
11954                                                isymbuf, symtab_hdr);
11955           break;
11956         case R_NDS32_LONGJUMP6:
11957           removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
11958                                                &insn_len, &seq_len, contents,
11959                                                isymbuf, symtab_hdr);
11960           break;
11961         case R_NDS32_LONGJUMP7:
11962           removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
11963                                                &insn_len, &seq_len, contents,
11964                                                isymbuf, symtab_hdr);
11965           break;
11966         case R_NDS32_LOADSTORE:
11967           removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
11968                                                internal_relocs, &insn_len,
11969                                                contents, isymbuf, symtab_hdr,
11970                                                load_store_relax);
11971           break;
11972         case R_NDS32_LO12S0_RELA:
11973         case R_NDS32_LO12S1_RELA:
11974         case R_NDS32_LO12S2_DP_RELA:
11975         case R_NDS32_LO12S2_SP_RELA:
11976         case R_NDS32_LO12S2_RELA:
11977           /* Relax for low part.  */
11978           nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
11979                                 contents, isymbuf, symtab_hdr);
11980
11981           /* It is impossible to delete blank, so just continue.  */
11982           continue;
11983         case R_NDS32_GOT_LO12:
11984         case R_NDS32_GOTOFF_LO12:
11985         case R_NDS32_PLTREL_LO12:
11986         case R_NDS32_PLT_GOTREL_LO12:
11987         case R_NDS32_GOTPC_LO12:
11988           /* Relax for PIC gp-relative low part.  */
11989           nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
11990                                    isymbuf, symtab_hdr);
11991
11992           /* It is impossible to delete blank, so just continue.  */
11993           continue;
11994         case R_NDS32_TLS_LE_LO12:
11995           /* Relax for LE TLS low part.  */
11996           nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
11997                                      isymbuf, symtab_hdr);
11998
11999           /* It is impossible to delete blank, so just continue.  */
12000           continue;
12001         case R_NDS32_TLS_LE_ADD:
12002           nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12003                                     contents, isymbuf, symtab_hdr, again);
12004           /* It is impossible to delete blank, so just continue.  */
12005           continue;
12006         case R_NDS32_TLS_LE_LS:
12007           nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12008                                    contents, isymbuf, symtab_hdr, again);
12009           continue;
12010         case R_NDS32_PTR:
12011           removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12012                                          &insn_len, &seq_len, contents);
12013           break;
12014         case R_NDS32_PLT_GOT_SUFF:
12015           nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12016                                        internal_relocs, contents,
12017                                        isymbuf, symtab_hdr, again);
12018           /* It is impossible to delete blank, so just continue.  */
12019           continue;
12020         case R_NDS32_GOT_SUFF:
12021           nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12022                                     internal_relocs, contents,
12023                                     symtab_hdr, again);
12024           /* It is impossible to delete blank, so just continue.  */
12025           continue;
12026         case R_NDS32_GOTOFF_SUFF:
12027           nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12028                                        internal_relocs, contents,
12029                                        isymbuf, symtab_hdr, again);
12030           /* It is impossible to delete blank, so just continue.  */
12031           continue;
12032         default:
12033           continue;
12034
12035         }
12036       if (removed && seq_len - insn_len > 0)
12037         {
12038           if (!insert_nds32_elf_blank
12039               (&relax_blank_list, irel->r_offset + insn_len,
12040                seq_len - insn_len))
12041             goto error_return;
12042           *again = TRUE;
12043         }
12044     }
12045
12046   calc_nds32_blank_total (relax_blank_list);
12047
12048   if (table->relax_fp_as_gp)
12049     {
12050       if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12051                                  irelend, isymbuf))
12052         goto error_return;
12053
12054       if (!*again)
12055         {
12056           if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12057                                                irelend))
12058             goto error_return;
12059         }
12060     }
12061
12062   nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12063
12064   if (!*again)
12065     {
12066       if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12067                                      &relax_blank_list, optimize, opt_size))
12068         goto error_return;
12069     }
12070
12071   /* It doesn't matter optimize_for_space_no_align anymore.
12072        If object file is assembled with flag '-Os',
12073        the we don't adjust jump-destination on 4-byte boundary.  */
12074
12075   if (relax_blank_list)
12076     {
12077       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12078       relax_blank_list = NULL;
12079     }
12080
12081   if (!*again)
12082     {
12083       /* Closing the section, so we don't relax it anymore.  */
12084       bfd_vma sec_size_align;
12085       Elf_Internal_Rela *tmp_rel;
12086
12087       /* Pad to alignment boundary.  Only handle current section alignment.  */
12088       sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12089                        & ((-1U) << sec->alignment_power);
12090       if ((sec_size_align - sec->size) & 0x2)
12091         {
12092           insn16 = NDS32_NOP16;
12093           bfd_putb16 (insn16, contents + sec->size);
12094           sec->size += 2;
12095         }
12096
12097       while (sec_size_align != sec->size)
12098         {
12099           insn = NDS32_NOP32;
12100           bfd_putb32 (insn, contents + sec->size);
12101           sec->size += 4;
12102         }
12103
12104       tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12105                                         irelend, R_NDS32_RELAX_ENTRY);
12106       if (tmp_rel != irelend)
12107         tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12108
12109       clean_nds32_elf_blank ();
12110     }
12111
12112 finish:
12113   if (internal_relocs != NULL
12114       && elf_section_data (sec)->relocs != internal_relocs)
12115     free (internal_relocs);
12116
12117   if (contents != NULL
12118       && elf_section_data (sec)->this_hdr.contents != contents)
12119     free (contents);
12120
12121   if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12122     free (isymbuf);
12123
12124   return result;
12125
12126 error_return:
12127   result = FALSE;
12128   goto finish;
12129 }
12130
12131 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12132 {
12133   {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12134   {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12135   {NULL, 0, 0, 0, 0}
12136 };
12137
12138 static bfd_boolean
12139 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12140                             struct bfd_link_info *info,
12141                             void *finfo ATTRIBUTE_UNUSED,
12142                             bfd_boolean (*func) (void *, const char *,
12143                                                  Elf_Internal_Sym *,
12144                                                  asection *,
12145                                                  struct elf_link_hash_entry *)
12146                             ATTRIBUTE_UNUSED)
12147 {
12148   FILE *sym_ld_script = NULL;
12149   struct elf_nds32_link_hash_table *table;
12150
12151   table = nds32_elf_hash_table (info);
12152   sym_ld_script = table->sym_ld_script;
12153
12154   if (check_start_export_sym)
12155     fprintf (sym_ld_script, "}\n");
12156
12157   return TRUE;
12158 }
12159
12160 static enum elf_reloc_type_class
12161 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12162                             const asection *rel_sec ATTRIBUTE_UNUSED,
12163                             const Elf_Internal_Rela *rela)
12164 {
12165   switch ((int) ELF32_R_TYPE (rela->r_info))
12166     {
12167     case R_NDS32_RELATIVE:
12168       return reloc_class_relative;
12169     case R_NDS32_JMP_SLOT:
12170       return reloc_class_plt;
12171     case R_NDS32_COPY:
12172       return reloc_class_copy;
12173     default:
12174       return reloc_class_normal;
12175     }
12176 }
12177
12178 /* Put target dependent option into info hash table.  */
12179 void
12180 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12181                                    int relax_fp_as_gp,
12182                                    int eliminate_gc_relocs,
12183                                    FILE * sym_ld_script, int load_store_relax,
12184                                    int target_optimize, int relax_status,
12185                                    int relax_round, FILE * ex9_export_file,
12186                                    FILE * ex9_import_file,
12187                                    int update_ex9_table, int ex9_limit,
12188                                    bfd_boolean ex9_loop_aware,
12189                                    bfd_boolean ifc_loop_aware)
12190 {
12191   struct elf_nds32_link_hash_table *table;
12192
12193   table = nds32_elf_hash_table (link_info);
12194   if (table == NULL)
12195     return;
12196
12197   table->relax_fp_as_gp = relax_fp_as_gp;
12198   table->eliminate_gc_relocs = eliminate_gc_relocs;
12199   table->sym_ld_script = sym_ld_script;
12200   table ->load_store_relax = load_store_relax;
12201   table->target_optimize = target_optimize;
12202   table->relax_status = relax_status;
12203   table->relax_round = relax_round;
12204   table->ex9_export_file = ex9_export_file;
12205   table->ex9_import_file = ex9_import_file;
12206   table->update_ex9_table = update_ex9_table;
12207   table->ex9_limit = ex9_limit;
12208   table->ex9_loop_aware = ex9_loop_aware;
12209   table->ifc_loop_aware = ifc_loop_aware;
12210 }
12211 \f
12212 /* These functions and data-structures are used for fp-as-gp
12213    optimization.  */
12214
12215 #define FAG_THRESHOLD   3       /* At least 3 gp-access.  */
12216 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12217    the read-only section and read-write section.  */
12218 #define FAG_WINDOW      (508 - 32)
12219
12220 /* An nds32_fag represent a gp-relative access.
12221    We find best fp-base by using a sliding window
12222    to find a base address which can cover most gp-access.  */
12223 struct nds32_fag
12224 {
12225   struct nds32_fag *next;       /* NULL-teminated linked list.  */
12226   bfd_vma addr;                 /* The address of this fag.  */
12227   Elf_Internal_Rela **relas;    /* The relocations associated with this fag.
12228                                    It is used for applying FP7U2_FLAG.  */
12229   int count;                    /* How many times this address is referred.
12230                                    There should be exactly `count' relocations
12231                                    in relas.  */
12232   int relas_capcity;            /* The buffer size of relas.
12233                                    We use an array instead of linked-list,
12234                                    and realloc is used to adjust buffer size.  */
12235 };
12236
12237 static void
12238 nds32_fag_init (struct nds32_fag *head)
12239 {
12240   memset (head, 0, sizeof (struct nds32_fag));
12241 }
12242
12243 static void
12244 nds32_fag_verify (struct nds32_fag *head)
12245 {
12246   struct nds32_fag *iter;
12247   struct nds32_fag *prev;
12248
12249   prev = NULL;
12250   iter = head->next;
12251   while (iter)
12252     {
12253       if (prev && prev->addr >= iter->addr)
12254         puts ("Bug in fp-as-gp insertion.");
12255       prev = iter;
12256       iter = iter->next;
12257     }
12258 }
12259
12260 /* Insert a fag in ascending order.
12261    If a fag of the same address already exists,
12262    they are chained by relas array.  */
12263
12264 static void
12265 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12266                   Elf_Internal_Rela * rel)
12267 {
12268   struct nds32_fag *iter;
12269   struct nds32_fag *new_fag;
12270   const int INIT_RELAS_CAP = 4;
12271
12272   for (iter = head;
12273        iter->next && iter->next->addr <= addr;
12274        iter = iter->next)
12275     /* Find somewhere to insert.  */ ;
12276
12277   /* `iter' will be equal to `head' if the list is empty.  */
12278   if (iter != head && iter->addr == addr)
12279     {
12280       /* The address exists in the list.
12281          Insert `rel' into relocation list, relas.  */
12282
12283       /* Check whether relas is big enough.  */
12284       if (iter->count >= iter->relas_capcity)
12285         {
12286           iter->relas_capcity *= 2;
12287           iter->relas = bfd_realloc
12288             (iter->relas, iter->relas_capcity * sizeof (void *));
12289         }
12290       iter->relas[iter->count++] = rel;
12291       return;
12292     }
12293
12294   /* This is a new address.  Create a fag node for it.  */
12295   new_fag = bfd_malloc (sizeof (struct nds32_fag));
12296   memset (new_fag, 0, sizeof (*new_fag));
12297   new_fag->addr = addr;
12298   new_fag->count = 1;
12299   new_fag->next = iter->next;
12300   new_fag->relas_capcity = INIT_RELAS_CAP;
12301   new_fag->relas = (Elf_Internal_Rela **)
12302     bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12303   new_fag->relas[0] = rel;
12304   iter->next = new_fag;
12305
12306   nds32_fag_verify (head);
12307 }
12308
12309 static void
12310 nds32_fag_free_list (struct nds32_fag *head)
12311 {
12312   struct nds32_fag *iter;
12313
12314   iter = head->next;
12315   while (iter)
12316     {
12317       struct nds32_fag *tmp = iter;
12318       iter = iter->next;
12319       free (tmp->relas);
12320       tmp->relas = NULL;
12321       free (tmp);
12322     }
12323 }
12324
12325 /* Find the best fp-base address.
12326    The relocation associated with that address is returned,
12327    so we can track the symbol instead of a fixed address.
12328
12329    When relaxation, the address of an datum may change,
12330    because a text section is shrinked, so the data section
12331    moves forward.  If the aligments of text and data section
12332    are different, their distance may change too.
12333    Therefore, tracking a fixed address is not appriate.  */
12334
12335 static int
12336 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12337 {
12338   struct nds32_fag *base;       /* First fag in the window.  */
12339   struct nds32_fag *last;       /* First fag outside the window.  */
12340   int accu = 0;                 /* Usage accumulation.  */
12341   struct nds32_fag *best;       /* Best fag.  */
12342   int baccu = 0;                /* Best accumulation.  */
12343
12344   /* Use first fag for initial, and find the last fag in the window.
12345
12346      In each iteration, we could simply subtract previous fag
12347      and accumulate following fags which are inside the window,
12348      untill we each the end.  */
12349
12350   if (head->next == NULL)
12351     {
12352       *bestpp = NULL;
12353       return 0;
12354     }
12355
12356   /* Initialize base.  */
12357   base = head->next;
12358   best = base;
12359   for (last = base;
12360        last && last->addr < base->addr + FAG_WINDOW;
12361        last = last->next)
12362     accu += last->count;
12363
12364   baccu = accu;
12365
12366   /* Record the best base in each iteration.  */
12367   while (base->next)
12368     {
12369       accu -= base->count;
12370       base = base->next;
12371       /* Account fags in window.  */
12372       for (/* Nothing.  */;
12373            last && last->addr < base->addr + FAG_WINDOW;
12374            last = last->next)
12375         accu += last->count;
12376
12377       /* A better fp-base?  */
12378       if (accu > baccu)
12379         {
12380           best = base;
12381           baccu = accu;
12382         }
12383     }
12384
12385   if (bestpp)
12386     *bestpp = best;
12387   return baccu;
12388 }
12389
12390 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12391    so we can convert it fo fp-relative access later.
12392    `best_fag' is the best fp-base.  Only those inside the window
12393    of best_fag is applied the flag.  */
12394
12395 static bfd_boolean
12396 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12397                       bfd *abfd, struct nds32_fag *best_fag,
12398                       Elf_Internal_Rela *internal_relocs,
12399                       Elf_Internal_Rela *irelend)
12400 {
12401   struct nds32_fag *ifag;
12402   bfd_vma best_fpbase, gp;
12403   bfd *output_bfd;
12404
12405   output_bfd = abfd->sections->output_section->owner;
12406   nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12407   best_fpbase = best_fag->addr;
12408
12409   if (best_fpbase > gp + sdata_range[1][1]
12410       || best_fpbase < gp - sdata_range[1][0])
12411     return FALSE;
12412
12413   /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12414      so we know they can be converted to lwi37.fp.   */
12415   for (ifag = best_fag;
12416        ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12417     {
12418       int i;
12419
12420       for (i = 0; i < ifag->count; i++)
12421         {
12422           Elf_Internal_Rela *insn16_rel;
12423           Elf_Internal_Rela *fag_rel;
12424
12425           fag_rel = ifag->relas[i];
12426
12427           /* Only if this is within the WINDOWS, FP7U2_FLAG
12428              is applied.  */
12429
12430           insn16_rel = find_relocs_at_address
12431             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12432
12433           if (insn16_rel != irelend)
12434             insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12435         }
12436     }
12437   return TRUE;
12438 }
12439
12440 /* Reset INSN16 to clean fp as gp.  */
12441
12442 static void
12443 nds32_fag_unmark_relax (struct nds32_fag *fag,
12444                         Elf_Internal_Rela *internal_relocs,
12445                         Elf_Internal_Rela *irelend)
12446 {
12447   struct nds32_fag *ifag;
12448   int i;
12449   Elf_Internal_Rela *insn16_rel;
12450   Elf_Internal_Rela *fag_rel;
12451
12452   for (ifag = fag; ifag; ifag = ifag->next)
12453     {
12454       for (i = 0; i < ifag->count; i++)
12455         {
12456           fag_rel = ifag->relas[i];
12457
12458           /* Restore the INSN16 relocation.  */
12459           insn16_rel = find_relocs_at_address
12460             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12461
12462           if (insn16_rel != irelend)
12463             insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12464         }
12465     }
12466 }
12467
12468 /* This is the main function of fp-as-gp optimization.
12469    It should be called by relax_section.  */
12470
12471 static bfd_boolean
12472 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12473                       bfd *abfd, asection *sec,
12474                       Elf_Internal_Rela *internal_relocs,
12475                       Elf_Internal_Rela *irelend,
12476                       Elf_Internal_Sym *isymbuf)
12477 {
12478   Elf_Internal_Rela *begin_rel = NULL;
12479   Elf_Internal_Rela *irel;
12480   struct nds32_fag fag_head;
12481   Elf_Internal_Shdr *symtab_hdr;
12482   bfd_byte *contents;
12483   bfd_boolean ifc_inside = FALSE;
12484
12485   /* FIXME: Can we bfd_elf_link_read_relocs for the relocs?  */
12486
12487   /* Per-function fp-base selection.
12488      1. Create a list for all the gp-relative access.
12489      2. Base on those gp-relative address,
12490         find a fp-base which can cover most access.
12491      3. Use the fp-base for fp-as-gp relaxation.
12492
12493      NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12494      we should
12495      1. delete the `la $fp, _FP_BASE_' instruction and
12496      2. not convert lwi.gp to lwi37.fp.
12497
12498      To delete the _FP_BASE_ instruction, we simply apply
12499      R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12500
12501      To suppress the conversion, we simply NOT to apply
12502      R_NDS32_INSN16_FP7U2_FLAG flag.  */
12503
12504   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12505
12506   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12507       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12508     return FALSE;
12509
12510   /* Check whether it is worth for fp-as-gp optimization,
12511      i.e., at least 3 gp-load.
12512
12513      Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12514      apply this optimization.  */
12515
12516   for (irel = internal_relocs; irel < irelend; irel++)
12517     {
12518       /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12519          One we enter the begin of the region, we track all the LW/ST
12520          instructions, so when we leave the region, we try to find
12521          the best fp-base address for those LW/ST instructions.  */
12522
12523       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12524           && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12525         {
12526           /* Begin of the region.  */
12527           if (begin_rel)
12528             /* xgettext:c-format */
12529             _bfd_error_handler (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12530
12531           begin_rel = irel;
12532           nds32_fag_init (&fag_head);
12533           ifc_inside = FALSE;
12534         }
12535       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12536                && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12537         {
12538           int accu;
12539           struct nds32_fag *best_fag, *tmp_fag;
12540           int dist;
12541
12542           /* End of the region.
12543              Check whether it is worth to do fp-as-gp.  */
12544
12545           if (begin_rel == NULL)
12546             {
12547               /* xgettext:c-format */
12548               _bfd_error_handler (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12549               continue;
12550             }
12551
12552           accu = nds32_fag_find_base (&fag_head, &best_fag);
12553
12554           /* Clean FP7U2_FLAG because they may set ever.  */
12555           tmp_fag = fag_head.next;
12556           nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12557
12558           /* Check if it is worth, and FP_BASE is near enough to SDA_BASE.  */
12559           if (accu < FAG_THRESHOLD
12560               || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12561                                         internal_relocs, irelend))
12562             {
12563               /* Not worth to do fp-as-gp.  */
12564               begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12565               begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12566               irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12567               irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12568               nds32_fag_free_list (&fag_head);
12569               begin_rel = NULL;
12570               continue;
12571             }
12572
12573           /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12574              so we use it to record the distance to the reloction of best
12575              fp-base.  */
12576           dist = best_fag->relas[0] - begin_rel;
12577           BFD_ASSERT (dist > 0 && dist < 0xffffff);
12578           /* Use high 16 bits of addend to record the _FP_BASE_ matched
12579              relocation.  And get the base value when relocating.  */
12580           begin_rel->r_addend &= (0x1 << 16) - 1;
12581           begin_rel->r_addend |= dist << 16;
12582
12583           nds32_fag_free_list (&fag_head);
12584           begin_rel = NULL;
12585         }
12586
12587       if (begin_rel == NULL || ifc_inside)
12588         /* Skip if we are not in the region of fp-as-gp.  */
12589         continue;
12590
12591       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12592           || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12593         {
12594           bfd_vma addr;
12595           uint32_t insn;
12596
12597           /* A gp-relative access is found.  Insert it to the fag-list.  */
12598
12599           /* Rt is necessary an RT3, so it can be converted to lwi37.fp.  */
12600           insn = bfd_getb32 (contents + irel->r_offset);
12601           if (!N32_IS_RT3 (insn))
12602             continue;
12603
12604           addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12605           nds32_fag_insert (&fag_head, addr, irel);
12606         }
12607       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12608         {
12609           begin_rel = NULL;
12610         }
12611       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12612                || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12613         {
12614           /* Suppress fp as gp when encounter ifc.  */
12615           ifc_inside = TRUE;
12616         }
12617     }
12618
12619   return TRUE;
12620 }
12621
12622 /* Remove unused `la $fp, _FD_BASE_' instruction.  */
12623
12624 static bfd_boolean
12625 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12626                                 Elf_Internal_Rela *internal_relocs,
12627                                 Elf_Internal_Rela *irelend)
12628 {
12629   Elf_Internal_Rela *irel;
12630   Elf_Internal_Shdr *symtab_hdr;
12631   bfd_byte *contents = NULL;
12632   nds32_elf_blank_t *relax_blank_list = NULL;
12633   bfd_boolean result = TRUE;
12634   bfd_boolean unused_region = FALSE;
12635
12636   /*
12637      NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12638      * R_NDS32_17IFC_PCREL_RELA
12639      * R_NDS32_10IFCU_PCREL_RELA
12640
12641      CASE??????????????
12642   */
12643
12644   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12645   nds32_get_section_contents (abfd, sec, &contents, TRUE);
12646
12647   for (irel = internal_relocs; irel < irelend; irel++)
12648     {
12649       /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12650          we marked to in previous pass.
12651          DO NOT scan relocations again, since we've alreadly decided it
12652          and set the flag.  */
12653       const char *syname;
12654       int syndx;
12655       uint32_t insn;
12656
12657       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12658           && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12659         unused_region = TRUE;
12660       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12661                && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12662         unused_region = FALSE;
12663
12664       /* We're not in the region.  */
12665       if (!unused_region)
12666         continue;
12667
12668       /* _FP_BASE_ must be a GLOBAL symbol.  */
12669       syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12670       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12671         continue;
12672
12673       /* The symbol name must be _FP_BASE_.  */
12674       syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12675       if (strcmp (syname, FP_BASE_NAME) != 0)
12676         continue;
12677
12678       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12679         {
12680           /* addi.gp  $fp, -256  */
12681           insn = bfd_getb32 (contents + irel->r_offset);
12682           if (insn != INSN_ADDIGP_TO_FP)
12683             continue;
12684         }
12685       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12686         {
12687           /* addi  $fp, $gp, -256  */
12688           insn = bfd_getb32 (contents + irel->r_offset);
12689           if (insn != INSN_ADDI_GP_TO_FP)
12690             continue;
12691         }
12692       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12693         {
12694           /* movi  $fp, FP_BASE  */
12695           insn = bfd_getb32 (contents + irel->r_offset);
12696           if (insn != INSN_MOVI_TO_FP)
12697             continue;
12698         }
12699       else
12700         continue;
12701
12702       /* We got here because a FP_BASE instruction is found.  */
12703       if (!insert_nds32_elf_blank_recalc_total
12704           (&relax_blank_list, irel->r_offset, 4))
12705         goto error_return;
12706     }
12707
12708 finish:
12709   if (relax_blank_list)
12710     {
12711       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12712       relax_blank_list = NULL;
12713     }
12714   return result;
12715
12716 error_return:
12717   result = FALSE;
12718   goto finish;
12719 }
12720
12721 /* This is a version of bfd_generic_get_relocated_section_contents.
12722    We need this variety because relaxation will modify the dwarf
12723    infomation.  When there is undefined symbol reference error mesage,
12724    linker need to dump line number where the symbol be used.  However
12725    the address is be relaxed, it can not get the original dwarf contents.
12726    The variety only modify function call for reading in the section.  */
12727
12728 static bfd_byte *
12729 nds32_elf_get_relocated_section_contents (bfd *abfd,
12730                                           struct bfd_link_info *link_info,
12731                                           struct bfd_link_order *link_order,
12732                                           bfd_byte *data,
12733                                           bfd_boolean relocatable,
12734                                           asymbol **symbols)
12735 {
12736   bfd *input_bfd = link_order->u.indirect.section->owner;
12737   asection *input_section = link_order->u.indirect.section;
12738   long reloc_size;
12739   arelent **reloc_vector;
12740   long reloc_count;
12741
12742   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12743   if (reloc_size < 0)
12744     return NULL;
12745
12746   /* Read in the section.  */
12747   if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
12748     return NULL;
12749
12750   if (reloc_size == 0)
12751     return data;
12752
12753   reloc_vector = (arelent **) bfd_malloc (reloc_size);
12754   if (reloc_vector == NULL)
12755     return NULL;
12756
12757   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
12758                                         reloc_vector, symbols);
12759   if (reloc_count < 0)
12760     goto error_return;
12761
12762   if (reloc_count > 0)
12763     {
12764       arelent **parent;
12765       for (parent = reloc_vector; *parent != NULL; parent++)
12766         {
12767           char *error_message = NULL;
12768           asymbol *symbol;
12769           bfd_reloc_status_type r;
12770
12771           symbol = *(*parent)->sym_ptr_ptr;
12772           if (symbol->section && discarded_section (symbol->section))
12773             {
12774               bfd_byte *p;
12775               static reloc_howto_type none_howto
12776                 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
12777                          "unused", FALSE, 0, 0, FALSE);
12778
12779               p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
12780               _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
12781                                    p);
12782               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
12783               (*parent)->addend = 0;
12784               (*parent)->howto = &none_howto;
12785               r = bfd_reloc_ok;
12786             }
12787           else
12788             r = bfd_perform_relocation (input_bfd, *parent, data,
12789                                         input_section,
12790                                         relocatable ? abfd : NULL,
12791                                         &error_message);
12792
12793           if (relocatable)
12794             {
12795               asection *os = input_section->output_section;
12796
12797               /* A partial link, so keep the relocs.  */
12798               os->orelocation[os->reloc_count] = *parent;
12799               os->reloc_count++;
12800             }
12801
12802           if (r != bfd_reloc_ok)
12803             {
12804               switch (r)
12805                 {
12806                 case bfd_reloc_undefined:
12807                   (*link_info->callbacks->undefined_symbol)
12808                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
12809                      input_bfd, input_section, (*parent)->address, TRUE);
12810                   break;
12811                 case bfd_reloc_dangerous:
12812                   BFD_ASSERT (error_message != NULL);
12813                   (*link_info->callbacks->reloc_dangerous)
12814                     (link_info, error_message,
12815                      input_bfd, input_section, (*parent)->address);
12816                   break;
12817                 case bfd_reloc_overflow:
12818                   (*link_info->callbacks->reloc_overflow)
12819                     (link_info, NULL,
12820                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
12821                      (*parent)->howto->name, (*parent)->addend,
12822                      input_bfd, input_section, (*parent)->address);
12823                   break;
12824                 case bfd_reloc_outofrange:
12825                   /* PR ld/13730:
12826                      This error can result when processing some partially
12827                      complete binaries.  Do not abort, but issue an error
12828                      message instead.  */
12829                   link_info->callbacks->einfo
12830                     /* xgettext:c-format */
12831                     (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
12832                      abfd, input_section, * parent);
12833                   goto error_return;
12834
12835                 default:
12836                   abort ();
12837                   break;
12838                 }
12839             }
12840         }
12841     }
12842
12843   free (reloc_vector);
12844   return data;
12845
12846 error_return:
12847   free (reloc_vector);
12848   return NULL;
12849 }
12850 \f
12851 /* Link-time IFC relaxation.
12852    In this optimization, we chains jump instructions
12853    of the same destination with ifcall.  */
12854
12855
12856 /* List to save jal and j relocation.  */
12857 struct elf_nds32_ifc_symbol_entry
12858 {
12859   asection *sec;
12860   struct elf_link_hash_entry *h;
12861   struct elf_nds32_ifc_irel_list *irel_head;
12862   unsigned long insn;
12863   int times;
12864   int enable;           /* Apply ifc.  */
12865   int ex9_enable;       /* Apply ifc after ex9.  */
12866   struct elf_nds32_ifc_symbol_entry *next;
12867 };
12868
12869 struct elf_nds32_ifc_irel_list
12870 {
12871   Elf_Internal_Rela *irel;
12872   asection *sec;
12873   bfd_vma addr;
12874   /* If this is set, then it is the last instruction for
12875      ifc-chain, so it must be keep for the actual branching.  */
12876   int keep;
12877   struct elf_nds32_ifc_irel_list *next;
12878 };
12879
12880 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
12881
12882 /* Insert symbol of jal and j for ifc.  */
12883
12884 static void
12885 nds32_elf_ifc_insert_symbol (asection *sec,
12886                              struct elf_link_hash_entry *h,
12887                              Elf_Internal_Rela *irel,
12888                              unsigned long insn)
12889 {
12890   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
12891
12892   /* Check there is target of existing entry the same as the new one.  */
12893   while (ptr != NULL)
12894     {
12895       if (((h == NULL && ptr->sec == sec
12896             && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
12897             && ptr->irel_head->irel->r_addend == irel->r_addend)
12898            || h != NULL)
12899           && ptr->h == h
12900           && ptr->insn == insn)
12901         {
12902           /* The same target exist, so insert into list.  */
12903           struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
12904
12905           while (irel_list->next != NULL)
12906             irel_list = irel_list->next;
12907           irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
12908           irel_list = irel_list->next;
12909           irel_list->irel = irel;
12910           irel_list->keep = 1;
12911
12912           if (h == NULL)
12913             irel_list->sec = NULL;
12914           else
12915             irel_list->sec = sec;
12916           irel_list->next = NULL;
12917           return;
12918         }
12919       if (ptr->next == NULL)
12920         break;
12921       ptr = ptr->next;
12922     }
12923
12924   /* There is no same target entry, so build a new one.  */
12925   if (ifc_symbol_head == NULL)
12926     {
12927       ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
12928       ptr = ifc_symbol_head;
12929     }
12930   else
12931     {
12932       ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
12933       ptr = ptr->next;
12934     }
12935
12936   ptr->h = h;
12937   ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
12938   ptr->irel_head->irel = irel;
12939   ptr->insn = insn;
12940   ptr->irel_head->keep = 1;
12941
12942   if (h == NULL)
12943     {
12944       /* Local symbols.  */
12945       ptr->sec = sec;
12946       ptr->irel_head->sec = NULL;
12947     }
12948   else
12949     {
12950       /* Global symbol.  */
12951       ptr->sec = NULL;
12952       ptr->irel_head->sec = sec;
12953     }
12954
12955   ptr->irel_head->next = NULL;
12956   ptr->times = 0;
12957   ptr->enable = 0;
12958   ptr->ex9_enable = 0;
12959   ptr->next = NULL;
12960 }
12961
12962 /* Gather all jal and j instructions.  */
12963
12964 static bfd_boolean
12965 nds32_elf_ifc_calc (struct bfd_link_info *info,
12966                     bfd *abfd, asection *sec)
12967 {
12968   Elf_Internal_Rela *internal_relocs;
12969   Elf_Internal_Rela *irelend;
12970   Elf_Internal_Rela *irel;
12971   Elf_Internal_Shdr *symtab_hdr;
12972   bfd_byte *contents = NULL;
12973   uint32_t insn, insn_with_reg;
12974   unsigned long r_symndx;
12975   struct elf_link_hash_entry *h;
12976   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
12977   struct elf_nds32_link_hash_table *table;
12978   bfd_boolean ifc_loop_aware;
12979
12980   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12981                                                TRUE /* keep_memory */);
12982   irelend = internal_relocs + sec->reloc_count;
12983   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12984
12985   /* Check if the object enable ifc.  */
12986   irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
12987                                  R_NDS32_RELAX_ENTRY);
12988
12989   if (irel == NULL
12990       || irel >= irelend
12991       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
12992       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
12993           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
12994     return TRUE;
12995
12996   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
12997     return FALSE;
12998
12999   table = nds32_elf_hash_table (info);
13000   ifc_loop_aware = table->ifc_loop_aware;
13001   while (irel != NULL && irel < irelend)
13002     {
13003       /* Traverse all relocation and gather all of them to build the list.  */
13004
13005       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13006         {
13007           if (ifc_loop_aware == 1
13008               && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13009             {
13010               /* Check the region if loop or not.  If it is true and
13011                  ifc-loop-aware is true, ignore the region till region end.  */
13012               while (irel != NULL
13013                      && irel < irelend
13014                      && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13015                          || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13016                 irel++;
13017             }
13018         }
13019
13020       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13021         {
13022           insn = bfd_getb32 (contents + irel->r_offset);
13023           nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13024           r_symndx = ELF32_R_SYM (irel->r_info);
13025           if (r_symndx < symtab_hdr->sh_info)
13026             {
13027               /* Local symbol.  */
13028               nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13029             }
13030           else
13031             {
13032               /* External symbol.  */
13033               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13034               nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13035             }
13036         }
13037       irel++;
13038     }
13039   return TRUE;
13040 }
13041
13042 /* Determine whether j and jal should be substituted.  */
13043
13044 static void
13045 nds32_elf_ifc_filter (struct bfd_link_info *info)
13046 {
13047   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13048   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13049   struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13050   struct elf_nds32_link_hash_table *table;
13051   int target_optimize;
13052   bfd_vma address;
13053
13054   table = nds32_elf_hash_table (info);
13055   target_optimize = table->target_optimize;
13056   while (ptr)
13057     {
13058       irel_ptr = ptr->irel_head;
13059       if (ptr->h == NULL)
13060         {
13061           /* Local symbol.  */
13062           irel_keeper = irel_ptr;
13063           while (irel_ptr && irel_ptr->next)
13064             {
13065               /* Check there is jump target can be used.  */
13066               if ((irel_ptr->next->irel->r_offset
13067                    - irel_keeper->irel->r_offset) > 1022)
13068                 irel_keeper = irel_ptr->next;
13069               else
13070                 {
13071                   ptr->enable = 1;
13072                   irel_ptr->keep = 0;
13073                 }
13074               irel_ptr = irel_ptr->next;
13075             }
13076         }
13077       else
13078         {
13079           /* Global symbol.  */
13080           /* We have to get the absolute address and decide
13081              whether to keep it or not.  */
13082           while (irel_ptr)
13083             {
13084               address = (irel_ptr->irel->r_offset
13085                          + irel_ptr->sec->output_section->vma
13086                          + irel_ptr->sec->output_offset);
13087               irel_ptr->addr = address;
13088               irel_ptr = irel_ptr->next;
13089             }
13090
13091           irel_ptr = ptr->irel_head;
13092           while (irel_ptr)
13093             {
13094               /* Sort by address.  */
13095               struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13096               struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13097               struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13098               struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13099
13100               /* Get the smallest one.  */
13101               while (irel_temp->next)
13102                 {
13103                   if (irel_temp->next->addr < irel_dest->addr)
13104                     {
13105                       irel_dest_prev = irel_temp;
13106                       irel_dest = irel_temp->next;
13107                     }
13108                   irel_temp = irel_temp->next;
13109                 }
13110
13111               if (irel_dest != irel_ptr)
13112                 {
13113                   if (irel_ptr_prev)
13114                     irel_ptr_prev->next = irel_dest;
13115                   if (irel_dest_prev)
13116                     irel_dest_prev->next = irel_ptr;
13117                   irel_temp = irel_ptr->next;
13118                   irel_ptr->next = irel_dest->next;
13119                   irel_dest->next = irel_temp;
13120                 }
13121               irel_ptr_prev = irel_ptr;
13122               irel_ptr = irel_ptr->next;
13123             }
13124
13125           irel_ptr = ptr->irel_head;
13126           irel_keeper = irel_ptr;
13127           while (irel_ptr && irel_ptr->next)
13128             {
13129               if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13130                 irel_keeper = irel_ptr->next;
13131               else
13132                 {
13133                   ptr->enable = 1;
13134                   irel_ptr->keep = 0;
13135                 }
13136               irel_ptr = irel_ptr->next;
13137             }
13138         }
13139
13140         /* Ex9 enable.  Reserve it for ex9.  */
13141       if ((target_optimize & NDS32_RELAX_EX9_ON)
13142           && ptr->irel_head != irel_keeper)
13143         ptr->enable = 0;
13144       ptr = ptr->next;
13145     }
13146 }
13147
13148 /* Determine whether j and jal should be substituted after ex9 done.  */
13149
13150 static void
13151 nds32_elf_ifc_filter_after_ex9 (void)
13152 {
13153   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13154   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13155
13156   while (ptr)
13157     {
13158       if (ptr->enable == 0)
13159         {
13160           /* Check whether ifc is applied or not.  */
13161           irel_ptr = ptr->irel_head;
13162           ptr->ex9_enable = 1;
13163           while (irel_ptr)
13164             {
13165               if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13166                 {
13167                   /* Ex9 already.  */
13168                   ptr->ex9_enable = 0;
13169                   break;
13170                 }
13171               irel_ptr = irel_ptr->next;
13172             }
13173         }
13174       ptr = ptr->next;
13175     }
13176 }
13177
13178 /* Wrapper to do ifc relaxation.  */
13179
13180 bfd_boolean
13181 nds32_elf_ifc_finish (struct bfd_link_info *info)
13182 {
13183   int relax_status;
13184   struct elf_nds32_link_hash_table *table;
13185
13186   table = nds32_elf_hash_table (info);
13187   relax_status = table->relax_status;
13188
13189   if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13190     nds32_elf_ifc_filter (info);
13191   else
13192     nds32_elf_ifc_filter_after_ex9 ();
13193
13194   if (!nds32_elf_ifc_replace (info))
13195     return FALSE;
13196
13197   if (table)
13198     table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13199   return TRUE;
13200 }
13201
13202 /* Traverse the result of ifc filter and replace it with ifcall9.  */
13203
13204 static bfd_boolean
13205 nds32_elf_ifc_replace (struct bfd_link_info *info)
13206 {
13207   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13208   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13209   nds32_elf_blank_t *relax_blank_list = NULL;
13210   bfd_byte *contents = NULL;
13211   Elf_Internal_Rela *internal_relocs;
13212   Elf_Internal_Rela *irel;
13213   Elf_Internal_Rela *irelend;
13214   unsigned short insn16 = INSN_IFCALL9;
13215   struct elf_nds32_link_hash_table *table;
13216   int relax_status;
13217
13218   table = nds32_elf_hash_table (info);
13219   relax_status = table->relax_status;
13220
13221   while (ptr)
13222     {
13223       /* Traverse the ifc gather list, and replace the
13224          filter entries by ifcall9.  */
13225       if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13226           || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13227               && ptr->ex9_enable == 1))
13228         {
13229           irel_ptr = ptr->irel_head;
13230           if (ptr->h == NULL)
13231             {
13232               /* Local symbol.  */
13233               internal_relocs = _bfd_elf_link_read_relocs
13234                 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13235               irelend = internal_relocs + ptr->sec->reloc_count;
13236
13237               if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13238                                                &contents, TRUE))
13239                 return FALSE;
13240
13241               while (irel_ptr)
13242                 {
13243                   if (irel_ptr->keep == 0 && irel_ptr->next)
13244                     {
13245                       /* The one can be replaced.  We have to check whether
13246                          there is any alignment point in the region.  */
13247                       irel = irel_ptr->irel;
13248                       while (((irel_ptr->next->keep == 0
13249                                && irel < irel_ptr->next->irel)
13250                               || (irel_ptr->next->keep == 1 && irel < irelend))
13251                              && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13252                                   && (irel->r_addend & 0x1f) == 2))
13253                         irel++;
13254                       if (irel >= irelend
13255                           || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13256                                && (irel->r_addend & 0x1f) == 2
13257                                && ((irel->r_offset - get_nds32_elf_blank_total
13258                                     (&relax_blank_list, irel->r_offset, 1))
13259                                    & 0x02) == 0))
13260                         {
13261                           /* Replace by ifcall9.  */
13262                           bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13263                           if (!insert_nds32_elf_blank_recalc_total
13264                               (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13265                             return FALSE;
13266                           irel_ptr->irel->r_info =
13267                             ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13268                                           R_NDS32_10IFCU_PCREL_RELA);
13269                         }
13270                     }
13271                   irel_ptr = irel_ptr->next;
13272                 }
13273
13274               /* Delete the redundant code.  */
13275               if (relax_blank_list)
13276                 {
13277                   nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13278                                                  relax_blank_list);
13279                   relax_blank_list = NULL;
13280                 }
13281             }
13282           else
13283             {
13284               /* Global symbol.  */
13285               while (irel_ptr)
13286                 {
13287                   if (irel_ptr->keep == 0 && irel_ptr->next)
13288                     {
13289                       /* The one can be replaced, and we have to check
13290                          whether there is any alignment point in the region.  */
13291                       internal_relocs = _bfd_elf_link_read_relocs
13292                         (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13293                          TRUE /* keep_memory */);
13294                       irelend = internal_relocs + irel_ptr->sec->reloc_count;
13295                       if (!nds32_get_section_contents (irel_ptr->sec->owner,
13296                                                        irel_ptr->sec, &contents,
13297                                                        TRUE))
13298                         return FALSE;
13299
13300                       irel = irel_ptr->irel;
13301                       while (((irel_ptr->sec == irel_ptr->next->sec
13302                                && irel_ptr->next->keep == 0
13303                                && irel < irel_ptr->next->irel)
13304                               || ((irel_ptr->sec != irel_ptr->next->sec
13305                                    || irel_ptr->next->keep == 1)
13306                                   && irel < irelend))
13307                              && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13308                                   && (irel->r_addend & 0x1f) == 2))
13309                         irel++;
13310                       if (irel >= irelend
13311                           || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13312                                && (irel->r_addend & 0x1f) == 2
13313                                && ((irel->r_offset
13314                                     - get_nds32_elf_blank_total (&relax_blank_list,
13315                                                             irel->r_offset, 1)) & 0x02) == 0))
13316                         {
13317                           /* Replace by ifcall9.  */
13318                           bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13319                           if (!insert_nds32_elf_blank_recalc_total
13320                               (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13321                             return FALSE;
13322
13323                           /* Delete the redundant code, and clear the relocation.  */
13324                           nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13325                                                          irel_ptr->sec,
13326                                                          relax_blank_list);
13327                           irel_ptr->irel->r_info =
13328                             ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13329                                           R_NDS32_10IFCU_PCREL_RELA);
13330                           relax_blank_list = NULL;
13331                         }
13332                     }
13333
13334                   irel_ptr = irel_ptr->next;
13335                 }
13336             }
13337         }
13338       ptr = ptr->next;
13339     }
13340
13341   return TRUE;
13342 }
13343
13344 /* Relocate ifcall.  */
13345
13346 static bfd_boolean
13347 nds32_elf_ifc_reloc (void)
13348 {
13349   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13350   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13351   struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13352   bfd_vma relocation, address;
13353   unsigned short insn16;
13354   bfd_byte *contents = NULL;
13355   static bfd_boolean done = FALSE;
13356
13357   if (done)
13358     return TRUE;
13359
13360   done = TRUE;
13361
13362   while (ptr)
13363     {
13364       /* Check the entry is enable ifcall.  */
13365       if (ptr->enable == 1 || ptr->ex9_enable == 1)
13366         {
13367           /* Get the reserve jump.  */
13368           irel_ptr = ptr->irel_head;
13369           while (irel_ptr)
13370             {
13371               if (irel_ptr->keep == 1)
13372                 {
13373                   irel_keeper = irel_ptr;
13374                   break;
13375                 }
13376               irel_ptr = irel_ptr->next;
13377             }
13378
13379           irel_ptr = ptr->irel_head;
13380           if (ptr->h == NULL)
13381             {
13382               /* Local symbol.  */
13383               if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13384                                                &contents, TRUE))
13385                 return FALSE;
13386
13387               while (irel_ptr)
13388                 {
13389                   if (irel_ptr->keep == 0
13390                       && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13391                     {
13392                       relocation = irel_keeper->irel->r_offset;
13393                       relocation = relocation - irel_ptr->irel->r_offset;
13394                       while (irel_keeper && relocation > 1022)
13395                         {
13396                           irel_keeper = irel_keeper->next;
13397                           if (irel_keeper && irel_keeper->keep == 1)
13398                             {
13399                               relocation = irel_keeper->irel->r_offset;
13400                               relocation = relocation - irel_ptr->irel->r_offset;
13401                             }
13402                         }
13403                       if (relocation > 1022)
13404                         {
13405                           /* Double check.  */
13406                           irel_keeper = ptr->irel_head;
13407                           while (irel_keeper)
13408                             {
13409                               if (irel_keeper->keep == 1)
13410                                 {
13411                                   relocation = irel_keeper->irel->r_offset;
13412                                   relocation = relocation - irel_ptr->irel->r_offset;
13413                                 }
13414                               if (relocation <= 1022)
13415                                 break;
13416                               irel_keeper = irel_keeper->next;
13417                             }
13418                           if (!irel_keeper)
13419                             return FALSE;
13420                         }
13421                       irel_ptr->irel->r_info =
13422                         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13423                                       R_NDS32_NONE);
13424                       insn16 = INSN_IFCALL9 | (relocation >> 1);
13425                       bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13426                     }
13427                   irel_ptr = irel_ptr->next;
13428                 }
13429             }
13430           else
13431             {
13432               /* Global symbol.  */
13433               while (irel_ptr)
13434                 {
13435                   if (irel_ptr->keep == 0
13436                       && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13437                     {
13438                       /* Get the distance between ifcall and jump.  */
13439                       relocation = (irel_keeper->irel->r_offset
13440                                     + irel_keeper->sec->output_section->vma
13441                                     + irel_keeper->sec->output_offset);
13442                       address = (irel_ptr->irel->r_offset
13443                                  + irel_ptr->sec->output_section->vma
13444                                  + irel_ptr->sec->output_offset);
13445                       relocation = relocation - address;
13446
13447                       /* The distance is over ragne, find callee again.  */
13448                       while (irel_keeper && relocation > 1022)
13449                         {
13450                           irel_keeper = irel_keeper->next;
13451                           if (irel_keeper && irel_keeper->keep ==1)
13452                             {
13453                               relocation = (irel_keeper->irel->r_offset
13454                                             + irel_keeper->sec->output_section->vma
13455                                             + irel_keeper->sec->output_offset);
13456                               relocation = relocation - address;
13457                             }
13458                         }
13459
13460                       if (relocation > 1022)
13461                         {
13462                           /* Double check.  */
13463                           irel_keeper = ptr->irel_head;
13464                           while (irel_keeper)
13465                             {
13466                               if (irel_keeper->keep == 1)
13467                                 {
13468
13469                                   relocation = (irel_keeper->irel->r_offset
13470                                                 + irel_keeper->sec->output_section->vma
13471                                                 + irel_keeper->sec->output_offset);
13472                                   relocation = relocation - address;
13473                                 }
13474                               if (relocation <= 1022)
13475                                 break;
13476                               irel_keeper = irel_keeper->next;
13477                             }
13478                           if (!irel_keeper)
13479                             return FALSE;
13480                         }
13481                       if (!nds32_get_section_contents
13482                           (irel_ptr->sec->owner, irel_ptr->sec, &contents, TRUE))
13483                         return FALSE;
13484                       insn16 = INSN_IFCALL9 | (relocation >> 1);
13485                       bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13486                       irel_ptr->irel->r_info =
13487                         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13488                                       R_NDS32_NONE);
13489                     }
13490                   irel_ptr =irel_ptr->next;
13491                 }
13492             }
13493         }
13494       ptr = ptr->next;
13495     }
13496
13497   return TRUE;
13498 }
13499
13500 /* End of IFC relaxation.  */
13501 \f
13502 /* EX9 Instruction Table Relaxation.  */
13503
13504 /* Global hash list.  */
13505 struct elf_link_hash_entry_list
13506 {
13507   struct elf_link_hash_entry *h;
13508   struct elf_link_hash_entry_list *next;
13509 };
13510
13511 /* Save different destination but same insn.  */
13512 struct elf_link_hash_entry_mul_list
13513 {
13514   /* Global symbol times.  */
13515   int times;
13516   /* Save relocation for each global symbol but useful??  */
13517   Elf_Internal_Rela *irel;
13518   /* For sethi, two sethi may have the same high-part but different low-parts.  */
13519   Elf_Internal_Rela rel_backup;
13520   struct elf_link_hash_entry_list *h_list;
13521   struct elf_link_hash_entry_mul_list *next;
13522 };
13523
13524 /* Instruction hash table.  */
13525 struct elf_nds32_code_hash_entry
13526 {
13527   struct bfd_hash_entry root;
13528   int times;
13529   /* For insn that can use relocation or constant ex: sethi.  */
13530   int const_insn;
13531   asection *sec;
13532   struct elf_link_hash_entry_mul_list *m_list;
13533   /* Using r_addend.  */
13534   Elf_Internal_Rela *irel;
13535   /* Using r_info.  */
13536   Elf_Internal_Rela rel_backup;
13537 };
13538
13539 /* Instruction count list.  */
13540 struct elf_nds32_insn_times_entry
13541 {
13542   const char *string;
13543   int times;
13544   int order;
13545   asection *sec;
13546   struct elf_link_hash_entry_mul_list *m_list;
13547   Elf_Internal_Rela *irel;
13548   Elf_Internal_Rela rel_backup;
13549   struct elf_nds32_insn_times_entry *next;
13550 };
13551
13552 /* J and JAL symbol list.  */
13553 struct elf_nds32_symbol_entry
13554 {
13555   char *string;
13556   unsigned long insn;
13557   struct elf_nds32_symbol_entry *next;
13558 };
13559
13560 /* Relocation list.  */
13561 struct elf_nds32_irel_entry
13562 {
13563   Elf_Internal_Rela *irel;
13564   struct elf_nds32_irel_entry *next;
13565 };
13566
13567 /* ex9.it insn need to be fixed.  */
13568 struct elf_nds32_ex9_refix
13569 {
13570   Elf_Internal_Rela *irel;
13571   asection *sec;
13572   struct elf_link_hash_entry *h;
13573   int order;
13574   struct elf_nds32_ex9_refix *next;
13575 };
13576
13577 static struct bfd_hash_table ex9_code_table;
13578 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13579 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13580
13581 /* EX9 hash function.  */
13582
13583 static struct bfd_hash_entry *
13584 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13585                              struct bfd_hash_table *table,
13586                              const char *string)
13587 {
13588   struct elf_nds32_code_hash_entry *ret;
13589
13590   /* Allocate the structure if it has not already been allocated by a
13591      subclass.  */
13592   if (entry == NULL)
13593     {
13594       entry = (struct bfd_hash_entry *)
13595         bfd_hash_allocate (table, sizeof (*ret));
13596       if (entry == NULL)
13597         return entry;
13598     }
13599
13600   /* Call the allocation method of the superclass.  */
13601   entry = bfd_hash_newfunc (entry, table, string);
13602   if (entry == NULL)
13603     return entry;
13604
13605   ret = (struct elf_nds32_code_hash_entry*) entry;
13606   ret->times = 0;
13607   ret->const_insn = 0;
13608   ret->m_list = NULL;
13609   ret->sec = NULL;
13610   ret->irel = NULL;
13611   return &ret->root;
13612 }
13613
13614 /* Insert ex9 entry
13615    this insert must be stable sorted by times.  */
13616
13617 static void
13618 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13619 {
13620   struct elf_nds32_insn_times_entry *temp;
13621   struct elf_nds32_insn_times_entry *temp2;
13622
13623   if (ex9_insn_head == NULL)
13624     {
13625       ex9_insn_head = ptr;
13626       ptr->next = NULL;
13627     }
13628   else
13629     {
13630       temp = ex9_insn_head;
13631       temp2 = ex9_insn_head;
13632       while (temp->next &&
13633              (temp->next->times >= ptr->times
13634               || temp->times == -1))
13635         {
13636           if (temp->times == -1)
13637             temp2 = temp;
13638           temp = temp->next;
13639         }
13640       if (ptr->times > temp->times && temp->times != -1)
13641         {
13642           ptr->next = temp;
13643           if (temp2->times == -1)
13644             temp2->next = ptr;
13645           else
13646             ex9_insn_head = ptr;
13647         }
13648       else if (temp->next == NULL)
13649         {
13650           temp->next = ptr;
13651           ptr->next = NULL;
13652         }
13653       else
13654         {
13655           ptr->next = temp->next;
13656           temp->next = ptr;
13657         }
13658     }
13659 }
13660
13661 /* Examine each insn times in hash table.
13662    Handle multi-link hash entry.
13663
13664    TODO: This function doesn't assign so much info since it is fake.  */
13665
13666 static int
13667 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13668 {
13669   struct elf_nds32_insn_times_entry *ptr;
13670   int times;
13671
13672   if (h->m_list == NULL)
13673     {
13674       /* Local symbol insn or insn without relocation.  */
13675       if (h->times < 3)
13676         return TRUE;
13677
13678       ptr = (struct elf_nds32_insn_times_entry *)
13679         bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13680       ptr->times = h->times;
13681       ptr->string = h->root.string;
13682       ptr->m_list = NULL;
13683       ptr->sec = h->sec;
13684       ptr->irel = h->irel;
13685       ptr->rel_backup = h->rel_backup;
13686       nds32_elf_ex9_insert_entry (ptr);
13687     }
13688   else
13689     {
13690       /* Global symbol insn.  */
13691       /* Only sethi insn has multiple m_list.  */
13692       struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13693
13694       times = 0;
13695       while (m_list)
13696         {
13697           times += m_list->times;
13698           m_list = m_list->next;
13699         }
13700       if (times >= 3)
13701         {
13702           m_list = h->m_list;
13703           ptr = (struct elf_nds32_insn_times_entry *)
13704             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13705           ptr->times = times; /* Use the total times.  */
13706           ptr->string = h->root.string;
13707           ptr->m_list = m_list;
13708           ptr->sec = h->sec;
13709           ptr->irel = m_list->irel;
13710           ptr->rel_backup = m_list->rel_backup;
13711           nds32_elf_ex9_insert_entry (ptr);
13712         }
13713       if (h->const_insn == 1)
13714         {
13715           /* sethi with constant value.  */
13716           if (h->times < 3)
13717             return TRUE;
13718
13719           ptr = (struct elf_nds32_insn_times_entry *)
13720             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13721           ptr->times = h->times;
13722           ptr->string = h->root.string;
13723           ptr->m_list = NULL;
13724           ptr->sec = NULL;
13725           ptr->irel = NULL;
13726           ptr->rel_backup = h->rel_backup;
13727           nds32_elf_ex9_insert_entry (ptr);
13728         }
13729     }
13730   return TRUE;
13731 }
13732
13733 /* Count each insn times in hash table.
13734    Handle multi-link hash entry.  */
13735
13736 static int
13737 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13738 {
13739   int reservation, times;
13740   unsigned long relocation, min_relocation;
13741   struct elf_nds32_insn_times_entry *ptr;
13742
13743   if (h->m_list == NULL)
13744     {
13745       /* Local symbol insn or insn without relocation.  */
13746       if (h->times < 3)
13747         return TRUE;
13748       ptr = (struct elf_nds32_insn_times_entry *)
13749         bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13750       ptr->times = h->times;
13751       ptr->string = h->root.string;
13752       ptr->m_list = NULL;
13753       ptr->sec = h->sec;
13754       ptr->irel = h->irel;
13755       ptr->rel_backup = h->rel_backup;
13756       nds32_elf_ex9_insert_entry (ptr);
13757     }
13758   else
13759     {
13760       /* Global symbol insn.  */
13761       /* Only sethi insn has multiple m_list.  */
13762       struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13763
13764       if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
13765           && m_list->next != NULL)
13766         {
13767           /* Sethi insn has different symbol or addend but has same hi20.  */
13768           times = 0;
13769           reservation = 1;
13770           relocation = 0;
13771           min_relocation = 0xffffffff;
13772           while (m_list)
13773             {
13774               /* Get the minimum sethi address
13775                  and calculate how many entry the sethi-list have to use.  */
13776               if ((m_list->h_list->h->root.type == bfd_link_hash_defined
13777                    || m_list->h_list->h->root.type == bfd_link_hash_defweak)
13778                   && (m_list->h_list->h->root.u.def.section != NULL
13779                       && m_list->h_list->h->root.u.def.section->output_section != NULL))
13780                 {
13781                   relocation = (m_list->h_list->h->root.u.def.value +
13782                                 m_list->h_list->h->root.u.def.section->output_section->vma +
13783                                 m_list->h_list->h->root.u.def.section->output_offset);
13784                   relocation += m_list->irel->r_addend;
13785                 }
13786               else
13787                 relocation = 0;
13788               if (relocation < min_relocation)
13789                 min_relocation = relocation;
13790               times += m_list->times;
13791               m_list = m_list->next;
13792             }
13793           if (min_relocation < ex9_relax_size)
13794             reservation = (min_relocation >> 12) + 1;
13795           else
13796             reservation = (min_relocation >> 12)
13797                           - ((min_relocation - ex9_relax_size) >> 12) + 1;
13798           if (reservation < (times / 3))
13799             {
13800               /* Efficient enough to use ex9.  */
13801               int i;
13802
13803               for (i = reservation ; i > 0; i--)
13804                 {
13805                   /* Allocate number of reservation ex9 entry.  */
13806                   ptr = (struct elf_nds32_insn_times_entry *)
13807                     bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13808                   ptr->times = h->m_list->times / reservation;
13809                   ptr->string = h->root.string;
13810                   ptr->m_list = h->m_list;
13811                   ptr->sec = h->sec;
13812                   ptr->irel = h->m_list->irel;
13813                   ptr->rel_backup = h->m_list->rel_backup;
13814                   nds32_elf_ex9_insert_entry (ptr);
13815                 }
13816             }
13817         }
13818       else
13819         {
13820           /* Normal global symbol that means no different address symbol
13821              using same ex9 entry.  */
13822           if (m_list->times >= 3)
13823             {
13824               ptr = (struct elf_nds32_insn_times_entry *)
13825                 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13826               ptr->times = m_list->times;
13827               ptr->string = h->root.string;
13828               ptr->m_list = h->m_list;
13829               ptr->sec = h->sec;
13830               ptr->irel = h->m_list->irel;
13831               ptr->rel_backup = h->m_list->rel_backup;
13832               nds32_elf_ex9_insert_entry (ptr);
13833             }
13834         }
13835
13836       if (h->const_insn == 1)
13837         {
13838           /* sethi with constant value.  */
13839           if (h->times < 3)
13840             return TRUE;
13841
13842           ptr = (struct elf_nds32_insn_times_entry *)
13843             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13844           ptr->times = h->times;
13845           ptr->string = h->root.string;
13846           ptr->m_list = NULL;
13847           ptr->sec = NULL;
13848           ptr->irel = NULL;
13849           ptr->rel_backup = h->rel_backup;
13850           nds32_elf_ex9_insert_entry (ptr);
13851         }
13852     }
13853
13854   return TRUE;
13855 }
13856
13857 /* Hash table traverse function.  */
13858
13859 static void
13860 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
13861 {
13862   unsigned int i;
13863
13864   ex9_code_table.frozen = 1;
13865   for (i = 0; i < ex9_code_table.size; i++)
13866     {
13867       struct bfd_hash_entry *p;
13868
13869       for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
13870         if (!func ((struct elf_nds32_code_hash_entry *) p))
13871           goto out;
13872     }
13873 out:
13874   ex9_code_table.frozen = 0;
13875 }
13876
13877
13878 /* Give order number to insn list.  */
13879
13880 static void
13881 nds32_elf_order_insn_times (struct bfd_link_info *info)
13882 {
13883   struct elf_nds32_insn_times_entry *ex9_insn;
13884   struct elf_nds32_insn_times_entry *temp = NULL;
13885   struct elf_nds32_link_hash_table *table;
13886   int ex9_limit;
13887   int number = 0;
13888
13889   if (ex9_insn_head == NULL)
13890     return;
13891
13892 /* The max number of entries is 512.  */
13893   ex9_insn = ex9_insn_head;
13894   table = nds32_elf_hash_table (info);
13895   ex9_limit = table->ex9_limit;
13896
13897   ex9_insn = ex9_insn_head;
13898
13899   while (ex9_insn != NULL && number < ex9_limit)
13900     {
13901       ex9_insn->order = number;
13902       number++;
13903       temp = ex9_insn;
13904       ex9_insn = ex9_insn->next;
13905     }
13906
13907   if (ex9_insn && temp)
13908     temp->next = NULL;
13909
13910   while (ex9_insn != NULL)
13911     {
13912       /* Free useless entry.  */
13913       temp = ex9_insn;
13914       ex9_insn = ex9_insn->next;
13915       free (temp);
13916     }
13917 }
13918
13919 /* Build .ex9.itable section.  */
13920
13921 static void
13922 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
13923 {
13924   asection *table_sec;
13925   struct elf_nds32_insn_times_entry *ptr;
13926   bfd *it_abfd;
13927   int number = 0;
13928   bfd_byte *contents = NULL;
13929
13930   for (it_abfd = link_info->input_bfds; it_abfd != NULL;
13931        it_abfd = it_abfd->link.next)
13932     {
13933       /* Find the section .ex9.itable, and put all entries into it.  */
13934       table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
13935       if (table_sec != NULL)
13936         {
13937           if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
13938             return;
13939
13940           for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
13941             number++;
13942
13943           table_sec->size = number * 4;
13944
13945           if (number == 0)
13946             return;
13947
13948           elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
13949           number = 0;
13950           for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
13951             {
13952               long val;
13953
13954               val = strtol (ptr->string, NULL, 16);
13955               bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
13956               number++;
13957             }
13958           break;
13959         }
13960     }
13961 }
13962
13963 /* Get insn with regs according to relocation type.  */
13964
13965 static void
13966 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
13967                              uint32_t insn, uint32_t *insn_with_reg)
13968 {
13969   reloc_howto_type *howto = NULL;
13970
13971   if (irel == NULL
13972       || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
13973           && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
13974              >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
13975     {
13976       *insn_with_reg = insn;
13977       return;
13978     }
13979
13980   howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
13981   *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
13982 }
13983
13984 /* Mask number of address bits according to relocation.  */
13985
13986 static unsigned long
13987 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
13988 {
13989   reloc_howto_type *howto = NULL;
13990
13991   if (irel == NULL
13992       || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
13993           && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
13994              >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
13995     return 0;
13996
13997   howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
13998   return howto->dst_mask;
13999 }
14000
14001 static void
14002 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14003                              struct elf_nds32_irel_entry *irel_ptr)
14004 {
14005   if (*irel_list == NULL)
14006     {
14007       *irel_list = irel_ptr;
14008       irel_ptr->next = NULL;
14009     }
14010   else
14011     {
14012       irel_ptr->next = *irel_list;
14013       *irel_list = irel_ptr;
14014     }
14015 }
14016
14017 static void
14018 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14019                           struct elf_link_hash_entry *h, int order)
14020 {
14021   struct elf_nds32_ex9_refix *ptr;
14022
14023   ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14024   ptr->sec = sec;
14025   ptr->irel = irel;
14026   ptr->h = h;
14027   ptr->order = order;
14028   ptr->next = NULL;
14029
14030   if (ex9_refix_head == NULL)
14031     ex9_refix_head = ptr;
14032   else
14033     {
14034       struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14035
14036       while (temp->next != NULL)
14037         temp = temp->next;
14038       temp->next = ptr;
14039     }
14040 }
14041
14042 enum
14043 {
14044   DATA_EXIST = 1,
14045   CLEAN_PRE = 1 << 1,
14046   PUSH_PRE = 1 << 2
14047 };
14048
14049 /* Check relocation type if supporting for ex9.  */
14050
14051 static int
14052 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14053                                 Elf_Internal_Rela **irel,
14054                                 Elf_Internal_Rela *irelend,
14055                                 nds32_elf_blank_t *relax_blank_list,
14056                                 asection *sec,bfd_vma *off,
14057                                 bfd_byte *contents)
14058 {
14059   /* Suppress ex9 if `.no_relax ex9' or inner loop.  */
14060   bfd_boolean nested_ex9, nested_loop;
14061   bfd_boolean ex9_loop_aware;
14062   /* We use the highest 1 byte of result to record
14063      how many bytes location counter has to move.  */
14064   int result = 0;
14065   Elf_Internal_Rela *irel_save = NULL;
14066   struct elf_nds32_link_hash_table *table;
14067
14068   table = nds32_elf_hash_table (info);
14069   ex9_loop_aware = table->ex9_loop_aware;
14070
14071   while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14072     {
14073       switch (ELF32_R_TYPE ((*irel)->r_info))
14074         {
14075         case R_NDS32_RELAX_REGION_BEGIN:
14076           /* Ignore code block.  */
14077           nested_ex9 = FALSE;
14078           nested_loop = FALSE;
14079           if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14080               || (ex9_loop_aware
14081                   && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14082             {
14083               /* Check the region if loop or not.  If it is true and
14084                  ex9-loop-aware is true, ignore the region till region end.  */
14085               /* To save the status for in .no_relax ex9 region and
14086                  loop region to conform the block can do ex9 relaxation.  */
14087               nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14088               nested_loop = (ex9_loop_aware
14089                              && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14090               while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14091                 {
14092                   (*irel)++;
14093                   if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14094                     {
14095                       /* There may be nested region.  */
14096                       if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14097                         nested_ex9 = TRUE;
14098                       else if (ex9_loop_aware
14099                                && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14100                         nested_loop = TRUE;
14101                     }
14102                   else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14103                     {
14104                       /* The end of region.  */
14105                       if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14106                         nested_ex9 = FALSE;
14107                       else if (ex9_loop_aware
14108                                && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14109                         nested_loop = FALSE;
14110                     }
14111                   else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14112                            && ((*irel)->r_addend & 0x1f) == 2)
14113                     {
14114                       /* Alignment exist in the region.  */
14115                       result |= CLEAN_PRE;
14116                       if (((*irel)->r_offset -
14117                            get_nds32_elf_blank_total (&relax_blank_list,
14118                                                       (*irel)->r_offset, 0)) & 0x02)
14119                         result |= PUSH_PRE;
14120                     }
14121                 }
14122               if ((*irel) >= irelend)
14123                 *off = sec->size;
14124               else
14125                 *off = (*irel)->r_offset;
14126
14127               /* The final instruction in the region, regard this one as data to ignore it.  */
14128               result |= DATA_EXIST;
14129               return result;
14130             }
14131           break;
14132
14133         case R_NDS32_LABEL:
14134           if (((*irel)->r_addend & 0x1f) == 2)
14135             {
14136               /* Check this point is align and decide to do ex9 or not.  */
14137               result |= CLEAN_PRE;
14138               if (((*irel)->r_offset -
14139                    get_nds32_elf_blank_total (&relax_blank_list,
14140                                               (*irel)->r_offset, 0)) & 0x02)
14141                 result |= PUSH_PRE;
14142             }
14143           break;
14144         case R_NDS32_32_RELA:
14145           /* Data.  */
14146           result |= (4 << 24);
14147           result |= DATA_EXIST;
14148           break;
14149         case R_NDS32_16_RELA:
14150           /* Data.  */
14151           result |= (2 << 24);
14152           result |= DATA_EXIST;
14153           break;
14154         case R_NDS32_DATA:
14155           /* Data.  */
14156           /* The least code alignment is 2.  If the data is only one byte,
14157              we have to shift one more byte.  */
14158           if ((*irel)->r_addend == 1)
14159             result |= ((*irel)->r_addend << 25) ;
14160           else
14161             result |= ((*irel)->r_addend << 24) ;
14162
14163           result |= DATA_EXIST;
14164           break;
14165
14166         case R_NDS32_25_PCREL_RELA:
14167         case R_NDS32_SDA16S3_RELA:
14168         case R_NDS32_SDA15S3_RELA:
14169         case R_NDS32_SDA15S3:
14170         case R_NDS32_SDA17S2_RELA:
14171         case R_NDS32_SDA15S2_RELA:
14172         case R_NDS32_SDA12S2_SP_RELA:
14173         case R_NDS32_SDA12S2_DP_RELA:
14174         case R_NDS32_SDA15S2:
14175         case R_NDS32_SDA18S1_RELA:
14176         case R_NDS32_SDA15S1_RELA:
14177         case R_NDS32_SDA15S1:
14178         case R_NDS32_SDA19S0_RELA:
14179         case R_NDS32_SDA15S0_RELA:
14180         case R_NDS32_SDA15S0:
14181         case R_NDS32_HI20_RELA:
14182         case R_NDS32_LO12S0_ORI_RELA:
14183         case R_NDS32_LO12S0_RELA:
14184         case R_NDS32_LO12S1_RELA:
14185         case R_NDS32_LO12S2_RELA:
14186           /* These relocation is supported ex9 relaxation currently.  */
14187           /* We have to save the relocation for using later, since we have
14188              to check there is any alignment in the same address.  */
14189           irel_save = *irel;
14190           break;
14191         default:
14192           /* Not support relocations.  */
14193           if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14194               && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14195               && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14196             {
14197               /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14198                  But we have to consider if there is any side-effect.  */
14199               if (!(result & DATA_EXIST))
14200                 {
14201                   /* We have to confirm there is no data relocation in the
14202                      same address.  In general case, this won't happen.  */
14203                   /* We have to do ex9 conservative, for those relocation not
14204                      considerd we ignore instruction.  */
14205                   result |= DATA_EXIST;
14206                   if (*(contents + *off) & 0x80)
14207                     result |= (2 << 24);
14208                   else
14209                     result |= (4 << 24);
14210                   break;
14211                 }
14212             }
14213         }
14214       if ((*irel) < irelend
14215           && ((*irel) + 1) < irelend
14216           && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14217         /* There are relocations pointing to the same address, we have to
14218            check all of them.  */
14219         (*irel)++;
14220       else
14221         {
14222           if (irel_save)
14223             *irel = irel_save;
14224           return result;
14225         }
14226     }
14227   return result;
14228 }
14229
14230 /* Replace with ex9 instruction.  */
14231
14232 static bfd_boolean
14233 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14234                          nds32_elf_blank_t **relax_blank_list,
14235                          struct elf_nds32_irel_entry *pre_irel_ptr,
14236                          struct elf_nds32_irel_entry **irel_list)
14237 {
14238   if (insn16 != 0)
14239     {
14240       /* Implement the ex9 relaxation.  */
14241       bfd_putb16 (insn16, contents + pre_off);
14242       if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14243                                                 pre_off + 2, 2))
14244         return FALSE;
14245       if (pre_irel_ptr != NULL)
14246         nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14247     }
14248   return TRUE;
14249 }
14250
14251 /* Replace input file instruction which is in ex9 itable.  */
14252
14253 static bfd_boolean
14254 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14255 {
14256   struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14257   bfd_byte *contents = NULL;
14258   bfd_vma off;
14259   uint16_t insn16, insn_ex9;
14260   /* `pre_*' are used to track previous instruction that can use ex9.it.  */
14261   bfd_vma pre_off = -1;
14262   uint16_t pre_insn16 = 0;
14263   struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14264   Elf_Internal_Rela *internal_relocs;
14265   Elf_Internal_Rela *irel;
14266   Elf_Internal_Rela *irelend;
14267   Elf_Internal_Shdr *symtab_hdr;
14268   Elf_Internal_Sym *isym = NULL;
14269   nds32_elf_blank_t *relax_blank_list = NULL;
14270   uint32_t insn = 0;
14271   uint32_t insn_with_reg = 0;
14272   uint32_t it_insn;
14273   uint32_t it_insn_with_reg;
14274   unsigned long r_symndx;
14275   asection *isec;
14276   struct elf_nds32_irel_entry *irel_list = NULL;
14277   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14278   int data_flag, do_replace, save_irel;
14279   struct elf_link_hash_entry_list *h_list;
14280
14281
14282   /* Load section instructions, relocations, and symbol table.  */
14283   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
14284       || !nds32_get_local_syms (abfd, sec, &isym))
14285     return FALSE;
14286   internal_relocs =
14287     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14288   irelend = internal_relocs + sec->reloc_count;
14289   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14290
14291   off = 0;
14292
14293   /* Check if the object enable ex9.  */
14294   irel = find_relocs_at_address (internal_relocs, internal_relocs,
14295                                  irelend, R_NDS32_RELAX_ENTRY);
14296
14297   /* Check this section trigger ex9 relaxation.  */
14298   if (irel == NULL
14299       || irel >= irelend
14300       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14301       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14302           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14303     return TRUE;
14304
14305   irel = internal_relocs;
14306
14307   /* Check alignment and fetch proper relocation.  */
14308   while (off < sec->size)
14309     {
14310       struct elf_link_hash_entry *h = NULL;
14311       struct elf_nds32_irel_entry *irel_ptr = NULL;
14312
14313       /* Syn the instruction and the relocation.  */
14314       while (irel != NULL && irel < irelend && irel->r_offset < off)
14315         irel++;
14316
14317       data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14318                                                   relax_blank_list, sec,
14319                                                   &off, contents);
14320       if (data_flag & PUSH_PRE)
14321         if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14322                                       &relax_blank_list, pre_irel_ptr,
14323                                       &irel_list))
14324           return FALSE;
14325
14326       if (data_flag & CLEAN_PRE)
14327         {
14328           pre_off = 0;
14329           pre_insn16 = 0;
14330           pre_irel_ptr = NULL;
14331         }
14332       if (data_flag & DATA_EXIST)
14333         {
14334           /* We save the move offset in the highest byte.  */
14335           off += (data_flag >> 24);
14336           continue;
14337         }
14338
14339       if (*(contents + off) & 0x80)
14340         {
14341           /* 2-byte instruction.  */
14342           off += 2;
14343           continue;
14344         }
14345
14346       /* Load the instruction and its opcode with register for comparing.  */
14347       ex9_insn = ex9_insn_head;
14348       insn = bfd_getb32 (contents + off);
14349       insn_with_reg = 0;
14350       while (ex9_insn)
14351         {
14352           it_insn = strtol (ex9_insn->string, NULL, 16);
14353           it_insn_with_reg = 0;
14354           do_replace = 0;
14355           save_irel = 0;
14356
14357           if (irel != NULL && irel < irelend && irel->r_offset == off)
14358             {
14359               /* Insn with relocation.  */
14360               nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14361
14362               if (ex9_insn->irel != NULL)
14363                 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14364                                              &it_insn_with_reg);
14365
14366               if (ex9_insn->irel != NULL
14367                   && (ELF32_R_TYPE (irel->r_info) ==
14368                       ELF32_R_TYPE (ex9_insn->irel->r_info))
14369                   && (insn_with_reg == it_insn_with_reg))
14370                 {
14371                   /* Insn relocation and format is the same as table entry.  */
14372
14373                   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14374                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14375                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14376                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14377                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14378                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14379                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14380                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14381                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14382                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14383                           && ELF32_R_TYPE (irel->r_info) <=
14384                           R_NDS32_SDA12S2_SP_RELA)
14385                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14386                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14387                     {
14388                       r_symndx = ELF32_R_SYM (irel->r_info);
14389                       if (r_symndx < symtab_hdr->sh_info)
14390                         {
14391                           /* Local symbol.  */
14392                           int shndx = isym[r_symndx].st_shndx;
14393
14394                           isec = elf_elfsections (abfd)[shndx]->bfd_section;
14395                           if (ex9_insn->sec == isec
14396                               && ex9_insn->irel->r_addend == irel->r_addend
14397                               && ex9_insn->irel->r_info == irel->r_info)
14398                             {
14399                               do_replace = 1;
14400                               save_irel = 1;
14401                             }
14402                         }
14403                       else
14404                         {
14405                           /* External symbol.  */
14406                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14407                           if (ex9_insn->m_list)
14408                             {
14409                               h_list = ex9_insn->m_list->h_list;
14410                               while (h_list)
14411                                 {
14412                                   if (h == h_list->h
14413                                       && (ex9_insn->m_list->irel->r_addend ==
14414                                           irel->r_addend))
14415                                     {
14416                                       do_replace = 1;
14417                                       save_irel = 1;
14418                                       break;
14419                                     }
14420                                   h_list = h_list->next;
14421                                 }
14422                             }
14423                         }
14424                     }
14425                   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14426                     {
14427                       r_symndx = ELF32_R_SYM (irel->r_info);
14428                       if (r_symndx < symtab_hdr->sh_info)
14429                         {
14430                           /* Local symbols.  Compare its base symbol and offset.  */
14431                           int shndx = isym[r_symndx].st_shndx;
14432
14433                           isec = elf_elfsections (abfd)[shndx]->bfd_section;
14434                           if (ex9_insn->sec == isec
14435                               && ex9_insn->irel->r_addend == irel->r_addend
14436                               && ex9_insn->irel->r_info == irel->r_info)
14437                             {
14438                               do_replace = 1;
14439                               save_irel = 1;
14440                             }
14441                         }
14442                       else
14443                         {
14444                           /* External symbol.  */
14445                           struct elf_link_hash_entry_mul_list *m_list;
14446
14447                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14448                           m_list = ex9_insn->m_list;
14449
14450                           while (m_list)
14451                             {
14452                               h_list = m_list->h_list;
14453
14454                               while (h_list)
14455                                 {
14456                                   if (h == h_list->h
14457                                       && (m_list->irel->r_addend
14458                                           == irel->r_addend))
14459                                     {
14460                                       do_replace = 1;
14461                                       save_irel = 1;
14462                                       if (ex9_insn->next
14463                                           && ex9_insn->m_list
14464                                           && ex9_insn->m_list == ex9_insn->next->m_list)
14465                                         {
14466                                           /* sethi multiple entry must be fixed */
14467                                           nds32_elf_ex9_insert_fix (sec, irel,
14468                                                                     h, ex9_insn->order);
14469                                         }
14470                                       break;
14471                                     }
14472                                   h_list = h_list->next;
14473                                 }
14474                               m_list = m_list->next;
14475                             }
14476                         }
14477                     }
14478                 }
14479
14480               /* Import table: Check the symbol hash table and the
14481                  jump target.  Only R_NDS32_25_PCREL_RELA now.  */
14482               else if (ex9_insn->times == -1
14483                        && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14484                 {
14485                   nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14486                   if (insn_with_reg == it_insn_with_reg)
14487                     {
14488                       char code[10];
14489                       bfd_vma relocation;
14490
14491                       r_symndx = ELF32_R_SYM (irel->r_info);
14492                       if (r_symndx >= symtab_hdr->sh_info)
14493                         {
14494                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14495                           if ((h->root.type == bfd_link_hash_defined
14496                                || h->root.type == bfd_link_hash_defweak)
14497                               && h->root.u.def.section != NULL
14498                               && h->root.u.def.section->output_section != NULL
14499                               && h->root.u.def.section->gc_mark == 1
14500                               && bfd_is_abs_section (h->root.u.def.section)
14501                               && h->root.u.def.value > sec->size)
14502                             {
14503                               relocation = h->root.u.def.value +
14504                                 h->root.u.def.section->output_section->vma +
14505                                 h->root.u.def.section->output_offset;
14506                               relocation += irel->r_addend;
14507                               insn = insn_with_reg
14508                                 | ((relocation >> 1) & 0xffffff);
14509                               snprintf (code, sizeof (code), "%08x", insn);
14510                               if (strcmp (code, ex9_insn->string) == 0)
14511                                 {
14512                                   do_replace = 1;
14513                                   save_irel = 1;
14514                                 }
14515                             }
14516                         }
14517                     }
14518                 }
14519               else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14520                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14521                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14522                 {
14523                   /* These relocations do not have to relocate contens, so it can
14524                      be regard as instruction without relocation.  */
14525                   if (insn == it_insn && ex9_insn->irel == NULL)
14526                     do_replace = 1;
14527                 }
14528             }
14529           else
14530             {
14531               /* Instruction without relocation, we only
14532                  have to compare their byte code.  */
14533               if (insn == it_insn && ex9_insn->irel == NULL)
14534                 do_replace = 1;
14535             }
14536
14537           /* Insntruction match so replacing the code here.  */
14538           if (do_replace == 1)
14539             {
14540               /* There are two formats of ex9 instruction.  */
14541               if (ex9_insn->order < 32)
14542                 insn_ex9 = INSN_EX9_IT_2;
14543               else
14544                 insn_ex9 = INSN_EX9_IT_1;
14545               insn16 = insn_ex9 | ex9_insn->order;
14546
14547               /* Insert ex9 instruction.  */
14548               nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14549                                        &relax_blank_list, pre_irel_ptr,
14550                                        &irel_list);
14551               pre_off = off;
14552               pre_insn16 = insn16;
14553
14554               if (save_irel)
14555                 {
14556                   /* For instuction with relocation do relax.  */
14557                   irel_ptr = (struct elf_nds32_irel_entry *)
14558                     bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14559                   irel_ptr->irel = irel;
14560                   irel_ptr->next = NULL;
14561                   pre_irel_ptr = irel_ptr;
14562                 }
14563               else
14564                 pre_irel_ptr = NULL;
14565               break;
14566             }
14567           ex9_insn = ex9_insn->next;
14568         }
14569       off += 4;
14570     }
14571
14572   /* Insert ex9 instruction.  */
14573   nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14574                            &relax_blank_list, pre_irel_ptr,
14575                            &irel_list);
14576
14577   /* Delete the redundant code.  */
14578   if (relax_blank_list)
14579     {
14580       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14581       relax_blank_list = NULL;
14582     }
14583
14584   /* Clear the relocation that is replaced by ex9.  */
14585   while (irel_list)
14586     {
14587       struct elf_nds32_irel_entry *irel_ptr;
14588
14589       irel_ptr = irel_list;
14590       irel_list = irel_ptr->next;
14591       irel_ptr->irel->r_info =
14592         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14593       free (irel_ptr);
14594     }
14595   return TRUE;
14596 }
14597
14598 /* Initialize ex9 hash table.  */
14599
14600 int
14601 nds32_elf_ex9_init (void)
14602 {
14603   if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14604                               sizeof (struct elf_nds32_code_hash_entry),
14605                               1023))
14606     {
14607       _bfd_error_handler (_("Linker: cannot init ex9 hash table error \n"));
14608       return FALSE;
14609     }
14610   return TRUE;
14611 }
14612
14613 /* Predict how many bytes will be relaxed with ex9 and ifc.  */
14614
14615 static void
14616 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14617 {
14618   struct elf_nds32_insn_times_entry *ex9_insn;
14619   struct elf_nds32_insn_times_entry *temp;
14620   int target_optimize;
14621   struct elf_nds32_link_hash_table *table;
14622
14623   if (ex9_insn_head == NULL)
14624     return;
14625
14626   table = nds32_elf_hash_table (info);
14627   target_optimize  = table->target_optimize;
14628   ex9_insn = ex9_insn_head;
14629   while (ex9_insn)
14630     {
14631       ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14632       temp = ex9_insn;
14633       ex9_insn = ex9_insn->next;
14634       free (temp);
14635     }
14636   ex9_insn_head = NULL;
14637
14638   if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14639     {
14640       /* Examine ifc reduce size.  */
14641       struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14642       struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14643       int size = 0;
14644
14645       while (ifc_ent)
14646         {
14647           if (ifc_ent->enable == 0)
14648             {
14649               /* Not ifc yet.  */
14650               irel_ptr = ifc_ent->irel_head;
14651               while (irel_ptr)
14652                 {
14653                   size += 2;
14654                   irel_ptr = irel_ptr->next;
14655                 }
14656             }
14657           size -= 2;
14658           ifc_ent = ifc_ent->next;
14659         }
14660       ex9_relax_size += size;
14661     }
14662 }
14663
14664 /* Finish ex9 table.  */
14665
14666 void
14667 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14668 {
14669   nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14670   nds32_elf_order_insn_times (link_info);
14671   nds32_elf_ex9_total_relax (link_info);
14672   /* Traverse the hash table and count its times.  */
14673   nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14674   nds32_elf_order_insn_times (link_info);
14675   nds32_elf_ex9_build_itable (link_info);
14676 }
14677
14678 /* Relocate the entries in ex9 table.  */
14679
14680 static bfd_vma
14681 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14682                           struct bfd_link_info *link_info)
14683 {
14684   Elf_Internal_Sym *isym = NULL;
14685   bfd_vma relocation = -1;
14686   struct elf_link_hash_entry *h;
14687
14688   if (ptr->m_list != NULL)
14689     {
14690       /* Global symbol.  */
14691       h = ptr->m_list->h_list->h;
14692       if ((h->root.type == bfd_link_hash_defined
14693            || h->root.type == bfd_link_hash_defweak)
14694           && h->root.u.def.section != NULL
14695           && h->root.u.def.section->output_section != NULL)
14696         {
14697
14698           relocation = h->root.u.def.value +
14699             h->root.u.def.section->output_section->vma +
14700             h->root.u.def.section->output_offset;
14701           relocation += ptr->m_list->irel->r_addend;
14702         }
14703       else
14704         relocation = 0;
14705     }
14706   else if (ptr->sec !=NULL)
14707     {
14708       /* Local symbol.  */
14709       Elf_Internal_Sym sym;
14710       asection *sec = NULL;
14711       asection isec;
14712       asection *isec_ptr = &isec;
14713       Elf_Internal_Rela irel_backup = *(ptr->irel);
14714       asection *sec_backup = ptr->sec;
14715       bfd *abfd = ptr->sec->owner;
14716
14717       if (!nds32_get_local_syms (abfd, sec, &isym))
14718         return FALSE;
14719       isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14720
14721       sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14722       if (sec != NULL)
14723         *isec_ptr = *sec;
14724       sym = *isym;
14725
14726       /* The purpose is same as elf_link_input_bfd.  */
14727       if (isec_ptr != NULL
14728           && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14729           && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14730         {
14731           sym.st_value =
14732             _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14733                                         elf_section_data (isec_ptr)->sec_info,
14734                                         isym->st_value);
14735         }
14736       relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14737                                             &ptr->sec, ptr->irel);
14738       if (ptr->irel != NULL)
14739         relocation += ptr->irel->r_addend;
14740
14741       /* Restore origin value since there may be some insntructions that
14742          could not be replaced with ex9.it.  */
14743       *(ptr->irel) = irel_backup;
14744       ptr->sec = sec_backup;
14745     }
14746
14747   return relocation;
14748 }
14749
14750 /* Import ex9 table and build list.  */
14751
14752 void
14753 nds32_elf_ex9_import_table (struct bfd_link_info *info)
14754 {
14755   int num = 0;
14756   bfd_byte *contents;
14757   FILE *ex9_import_file;
14758   int update_ex9_table;
14759   struct elf_nds32_link_hash_table *table;
14760
14761   table = nds32_elf_hash_table (info);
14762   ex9_import_file = table->ex9_import_file;
14763   rewind (table->ex9_import_file);
14764
14765   contents = bfd_malloc (sizeof (bfd_byte) * 4);
14766
14767   /* Read instructions from the input file and build the list.  */
14768   while (!feof (ex9_import_file))
14769     {
14770       unsigned long insn;
14771       char *code;
14772       struct elf_nds32_insn_times_entry *ptr;
14773       size_t nread;
14774
14775       nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
14776       /* Ignore the final byte 0x0a.  */
14777       if (nread < 1)
14778         break;
14779       insn = bfd_getb32 (contents);
14780       code = bfd_malloc (sizeof (char) * 9);
14781       snprintf (code, 9, "%08lx", (insn & 0xffffffff));
14782       ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14783       ptr->string = code;
14784       ptr->order = num;
14785       ptr->times = -1;
14786       ptr->sec = NULL;
14787       ptr->m_list = NULL;
14788       ptr->rel_backup.r_offset = 0;
14789       ptr->rel_backup.r_info = 0;
14790       ptr->rel_backup.r_addend = 0;
14791       ptr->irel = NULL;
14792       ptr->next = NULL;
14793       nds32_elf_ex9_insert_entry (ptr);
14794       num++;
14795     }
14796
14797   update_ex9_table = table->update_ex9_table;
14798   if (update_ex9_table == 1)
14799     {
14800       /* It has to consider of sethi need to use multiple page
14801          but it not be done yet.  */
14802       nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14803       nds32_elf_order_insn_times (info);
14804     }
14805 }
14806
14807 /* Export ex9 table.  */
14808
14809 static void
14810 nds32_elf_ex9_export (struct bfd_link_info *info,
14811                       bfd_byte *contents, int size)
14812 {
14813   FILE *ex9_export_file;
14814   struct elf_nds32_link_hash_table *table;
14815
14816   table = nds32_elf_hash_table (info);
14817   ex9_export_file = table->ex9_export_file;
14818   fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
14819   fclose (ex9_export_file);
14820 }
14821
14822 /* Adjust relocations of J and JAL in ex9.itable.
14823    Export ex9 table.  */
14824
14825 static void
14826 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
14827 {
14828   asection *table_sec = NULL;
14829   struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14830   struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
14831   bfd *it_abfd;
14832   uint32_t insn, insn_with_reg, source_insn;
14833   bfd_byte *contents = NULL, *source_contents = NULL;
14834   int size = 0;
14835   bfd_vma gp;
14836   int shift, update_ex9_table, offset = 0;
14837   reloc_howto_type *howto = NULL;
14838   Elf_Internal_Rela rel_backup;
14839   unsigned short insn_ex9;
14840   struct elf_nds32_link_hash_table *table;
14841   FILE *ex9_export_file;
14842   static bfd_boolean done = FALSE;
14843
14844   if (done)
14845     return;
14846
14847   done = TRUE;
14848
14849   table = nds32_elf_hash_table (link_info);
14850   if (table)
14851     table->relax_status |= NDS32_RELAX_EX9_DONE;
14852
14853
14854   update_ex9_table = table->update_ex9_table;
14855   /* Generated ex9.itable exactly.  */
14856   if (update_ex9_table == 0)
14857     {
14858       for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14859            it_abfd = it_abfd->link.next)
14860         {
14861           table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14862           if (table_sec != NULL)
14863             break;
14864         }
14865
14866       if (table_sec != NULL)
14867         {
14868           bfd *output_bfd;
14869
14870           output_bfd = table_sec->output_section->owner;
14871           nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
14872           if (table_sec->size == 0)
14873             return;
14874
14875           if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
14876             return;
14877         }
14878     }
14879   else
14880     {
14881       /* Set gp.  */
14882       bfd *output_bfd;
14883
14884       output_bfd = link_info->input_bfds->sections->output_section->owner;
14885       nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
14886       contents = bfd_malloc (sizeof (bfd_byte) * 2048);
14887     }
14888
14889   /* Relocate instruction.  */
14890   while (ex9_insn)
14891     {
14892       bfd_vma relocation, min_relocation = 0xffffffff;
14893
14894       insn = strtol (ex9_insn->string, NULL, 16);
14895       insn_with_reg = 0;
14896       if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
14897         {
14898           if (ex9_insn->m_list)
14899             rel_backup = ex9_insn->m_list->rel_backup;
14900           else
14901             rel_backup = ex9_insn->rel_backup;
14902
14903           nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
14904           howto =
14905             bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
14906                                                    (rel_backup.r_info));
14907           shift = howto->rightshift;
14908           if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
14909               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
14910               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
14911               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
14912               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
14913             {
14914               relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
14915               insn =
14916                 insn_with_reg | ((relocation >> shift) &
14917                                  nds32_elf_irel_mask (&rel_backup));
14918               bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
14919             }
14920           else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
14921                     && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
14922                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
14923                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
14924                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
14925                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
14926                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
14927                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
14928             {
14929               relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
14930               insn =
14931                 insn_with_reg | (((relocation - gp) >> shift) &
14932                                  nds32_elf_irel_mask (&rel_backup));
14933               bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
14934             }
14935           else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
14936             {
14937               /* Sethi may be multiple entry for one insn.  */
14938               if (ex9_insn->next && ex9_insn->m_list
14939                   && ex9_insn->m_list == ex9_insn->next->m_list)
14940                 {
14941                   struct elf_link_hash_entry_mul_list *m_list;
14942                   struct elf_nds32_ex9_refix *fix_ptr;
14943                   struct elf_link_hash_entry *h;
14944
14945                   temp_ptr = ex9_insn;
14946                   temp_ptr2 = ex9_insn;
14947                   m_list = ex9_insn->m_list;
14948                   while (m_list)
14949                     {
14950                       h = m_list->h_list->h;
14951                       relocation = h->root.u.def.value +
14952                         h->root.u.def.section->output_section->vma +
14953                         h->root.u.def.section->output_offset;
14954                       relocation += m_list->irel->r_addend;
14955
14956                       if (relocation < min_relocation)
14957                         min_relocation = relocation;
14958                       m_list = m_list->next;
14959                     }
14960                   relocation = min_relocation;
14961
14962                   /* Put insntruction into ex9 table.  */
14963                   insn = insn_with_reg
14964                     | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
14965                   bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
14966                   relocation = relocation + 0x1000;     /* hi20 */
14967
14968                   while (ex9_insn->next && ex9_insn->m_list
14969                          && ex9_insn->m_list == ex9_insn->next->m_list)
14970                     {
14971                       /* Multiple sethi.  */
14972                       ex9_insn = ex9_insn->next;
14973                       size += 4;
14974                       insn =
14975                         insn_with_reg | ((relocation >> shift) &
14976                                          nds32_elf_irel_mask (&rel_backup));
14977                       bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
14978                       relocation = relocation + 0x1000; /* hi20 */
14979                     }
14980
14981                   fix_ptr = ex9_refix_head;
14982                   while (fix_ptr)
14983                     {
14984                       /* Fix ex9 insn.  */
14985                       /* temp_ptr2 points to the head of multiple sethi.  */
14986                       temp_ptr = temp_ptr2;
14987                       while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
14988                         {
14989                           fix_ptr = fix_ptr->next;
14990                         }
14991                       if (fix_ptr->order != temp_ptr->order)
14992                         break;
14993
14994                       /* Set source insn.  */
14995                       relocation =
14996                         fix_ptr->h->root.u.def.value +
14997                         fix_ptr->h->root.u.def.section->output_section->vma +
14998                         fix_ptr->h->root.u.def.section->output_offset;
14999                       relocation += fix_ptr->irel->r_addend;
15000                       /* sethi imm is imm20s.  */
15001                       source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15002
15003                       while (temp_ptr)
15004                         {
15005                           /* Match entry and source code.  */
15006                           insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15007                           if (insn == source_insn)
15008                             {
15009                               /* Fix the ex9 insn.  */
15010                               if (temp_ptr->order != fix_ptr->order)
15011                                 {
15012                                   if (!nds32_get_section_contents
15013                                          (fix_ptr->sec->owner, fix_ptr->sec,
15014                                           &source_contents, TRUE))
15015                                     _bfd_error_handler
15016                                       (_("Linker: error cannot fixed ex9 relocation \n"));
15017                                   if (temp_ptr->order < 32)
15018                                     insn_ex9 = INSN_EX9_IT_2;
15019                                   else
15020                                     insn_ex9 = INSN_EX9_IT_1;
15021                                   insn_ex9 = insn_ex9 | temp_ptr->order;
15022                                   bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15023                                 }
15024                                 break;
15025                             }
15026                           else
15027                             {
15028                               if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15029                                 _bfd_error_handler
15030                                   (_("Linker: error cannot fixed ex9 relocation \n"));
15031                               else
15032                                 temp_ptr = temp_ptr->next;
15033                             }
15034                         }
15035                       fix_ptr = fix_ptr->next;
15036                     }
15037                 }
15038               else
15039                 {
15040                   relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15041                   insn = insn_with_reg
15042                          | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15043                   bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15044                 }
15045             }
15046         }
15047       else
15048         {
15049           /* Insn without relocation does not have to be fixed
15050              if need to update export table.  */
15051           if (update_ex9_table == 1)
15052             bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15053         }
15054       ex9_insn = ex9_insn->next;
15055       size += 4;
15056     }
15057
15058   ex9_export_file = table->ex9_export_file;
15059   if (ex9_export_file != NULL)
15060     nds32_elf_ex9_export (link_info, contents, table_sec->size);
15061   else if (update_ex9_table == 1)
15062     {
15063       table->ex9_export_file = table->ex9_import_file;
15064       rewind (table->ex9_export_file);
15065       nds32_elf_ex9_export (link_info, contents, size);
15066     }
15067 }
15068
15069 /* Generate ex9 hash table.  */
15070
15071 static bfd_boolean
15072 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15073                                 struct bfd_link_info *link_info)
15074 {
15075   Elf_Internal_Rela *internal_relocs;
15076   Elf_Internal_Rela *irelend;
15077   Elf_Internal_Rela *irel;
15078   Elf_Internal_Rela *jrel;
15079   Elf_Internal_Rela rel_backup;
15080   Elf_Internal_Shdr *symtab_hdr;
15081   Elf_Internal_Sym *isym = NULL;
15082   asection *isec;
15083   struct elf_link_hash_entry **sym_hashes;
15084   bfd_byte *contents = NULL;
15085   bfd_vma off = 0;
15086   unsigned long r_symndx;
15087   uint32_t insn, insn_with_reg;
15088   struct elf_link_hash_entry *h;
15089   int data_flag, shift, align;
15090   bfd_vma relocation;
15091   /* Suppress ex9 if `.no_relax ex9' or inner loop.  */
15092   reloc_howto_type *howto = NULL;
15093
15094   sym_hashes = elf_sym_hashes (abfd);
15095   /* Load section instructions, relocations, and symbol table.  */
15096   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
15097     return FALSE;
15098
15099   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15100                                                TRUE /* keep_memory */);
15101   irelend = internal_relocs + sec->reloc_count;
15102   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15103   if (!nds32_get_local_syms (abfd, sec, &isym))
15104     return FALSE;
15105
15106   /* Check the object if enable ex9.  */
15107   irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15108                                  R_NDS32_RELAX_ENTRY);
15109
15110   /* Check this section trigger ex9 relaxation.  */
15111   if (irel == NULL
15112       || irel >= irelend
15113       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15114       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15115           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15116     return TRUE;
15117
15118   irel = internal_relocs;
15119
15120   /* Push each insn into hash table.  */
15121   while (off < sec->size)
15122     {
15123       char code[10];
15124       struct elf_nds32_code_hash_entry *entry;
15125
15126       while (irel != NULL && irel < irelend && irel->r_offset < off)
15127         irel++;
15128
15129       data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15130                                                   NULL, sec, &off, contents);
15131       if (data_flag & DATA_EXIST)
15132         {
15133           /* We save the move offset in the highest byte.  */
15134           off += (data_flag >> 24);
15135           continue;
15136         }
15137
15138       if (*(contents + off) & 0x80)
15139         {
15140           off += 2;
15141         }
15142       else
15143         {
15144           h = NULL;
15145           isec = NULL;
15146           jrel = NULL;
15147           rel_backup.r_info = 0;
15148           rel_backup.r_offset = 0;
15149           rel_backup.r_addend = 0;
15150           /* Load the instruction and its opcode with register for comparing.  */
15151           insn = bfd_getb32 (contents + off);
15152           insn_with_reg = 0;
15153           if (irel != NULL && irel < irelend && irel->r_offset == off)
15154             {
15155               nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15156               howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15157               shift = howto->rightshift;
15158               align = (1 << shift) - 1;
15159               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15160                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15161                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15162                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15163                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15164                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15165                   ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15166                      && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15167                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15168                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15169                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15170                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15171                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15172                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15173                 {
15174                   r_symndx = ELF32_R_SYM (irel->r_info);
15175                   jrel = irel;
15176                   rel_backup = *irel;
15177                   if (r_symndx < symtab_hdr->sh_info)
15178                     {
15179                       /* Local symbol.  */
15180                       int shndx = isym[r_symndx].st_shndx;
15181
15182                       bfd_vma st_value = (isym + r_symndx)->st_value;
15183                       isec = elf_elfsections (abfd)[shndx]->bfd_section;
15184                       relocation = (isec->output_section->vma + isec->output_offset
15185                                     + st_value + irel->r_addend);
15186                     }
15187                   else
15188                     {
15189                       /* External symbol.  */
15190                       bfd_boolean warned ATTRIBUTE_UNUSED;
15191                       bfd_boolean ignored ATTRIBUTE_UNUSED;
15192                       bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15193                       asection *sym_sec;
15194
15195                       /* Maybe there is a better way to get h and relocation */
15196                       RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15197                                                r_symndx, symtab_hdr, sym_hashes,
15198                                                h, sym_sec, relocation,
15199                                                unresolved_reloc, warned, ignored);
15200                       relocation += irel->r_addend;
15201                       if ((h->root.type != bfd_link_hash_defined
15202                            && h->root.type != bfd_link_hash_defweak)
15203                           || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15204                         {
15205                           off += 4;
15206                           continue;
15207                         }
15208                     }
15209
15210                   /* Check for gp relative instruction alignment.  */
15211                   if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15212                        && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15213                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15214                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15215                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15216                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15217                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15218                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15219                     {
15220                       bfd_vma gp;
15221                       bfd *output_bfd = sec->output_section->owner;
15222                       bfd_reloc_status_type r;
15223
15224                       /* If the symbol is in the abs section, the out_bfd will be null.
15225                          This happens when the relocation has a symbol@GOTOFF.  */
15226                       r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15227                       if (r != bfd_reloc_ok)
15228                         {
15229                           off += 4;
15230                           continue;
15231                         }
15232
15233                       relocation -= gp;
15234
15235                       /* Make sure alignment is correct.  */
15236                       if (relocation & align)
15237                         {
15238                           /* Incorrect alignment.  */
15239                           _bfd_error_handler
15240                             /* xgettext:c-format */
15241                             (_("%B: warning: unaligned small data access "
15242                                "for entry: {%Ld, %Ld, %Ld}, addr = %#Lx, align = %#x"),
15243                              abfd, irel->r_offset,
15244                              irel->r_info, irel->r_addend, relocation, align);
15245                           off += 4;
15246                           continue;
15247                         }
15248                     }
15249
15250                   insn = insn_with_reg
15251                     | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15252                 }
15253               else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15254                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15255                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15256                 {
15257                   /* These relocations do not have to relocate contens, so it can
15258                      be regard as instruction without relocation.  */
15259                 }
15260               else
15261                 {
15262                   off += 4;
15263                   continue;
15264                 }
15265             }
15266
15267           snprintf (code, sizeof (code), "%08x", insn);
15268           /* Copy "code".  */
15269           entry = (struct elf_nds32_code_hash_entry*)
15270             bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15271           if (entry == NULL)
15272             {
15273               _bfd_error_handler
15274                 (_("failed creating ex9.it %s hash table entry"), code);
15275               return FALSE;
15276             }
15277           if (h)
15278             {
15279               if (h->root.type == bfd_link_hash_undefined)
15280                 return TRUE;
15281               /* Global symbol.  */
15282               /* In order to do sethi with different symbol but same value.  */
15283               if (entry->m_list == NULL)
15284                 {
15285                   struct elf_link_hash_entry_mul_list *m_list_new;
15286                   struct elf_link_hash_entry_list *h_list_new;
15287
15288                   m_list_new = (struct elf_link_hash_entry_mul_list *)
15289                     bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15290                   h_list_new = (struct elf_link_hash_entry_list *)
15291                     bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15292                   entry->m_list = m_list_new;
15293                   m_list_new->h_list = h_list_new;
15294                   m_list_new->rel_backup = rel_backup;
15295                   m_list_new->times = 1;
15296                   m_list_new->irel = jrel;
15297                   m_list_new->next = NULL;
15298                   h_list_new->h = h;
15299                   h_list_new->next = NULL;
15300                 }
15301               else
15302                 {
15303                   struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15304                   struct elf_link_hash_entry_list *h_list;
15305
15306                   while (m_list)
15307                     {
15308                       /* Build the different symbols that point to the same address.  */
15309                       h_list = m_list->h_list;
15310                       if (h_list->h->root.u.def.value == h->root.u.def.value
15311                           && h_list->h->root.u.def.section->output_section->vma
15312                              == h->root.u.def.section->output_section->vma
15313                           && h_list->h->root.u.def.section->output_offset
15314                              == h->root.u.def.section->output_offset
15315                           && m_list->rel_backup.r_addend == rel_backup.r_addend)
15316                         {
15317                           m_list->times++;
15318                           m_list->irel = jrel;
15319                           while (h_list->h != h && h_list->next)
15320                             h_list = h_list->next;
15321                           if (h_list->h != h)
15322                             {
15323                               struct elf_link_hash_entry_list *h_list_new;
15324
15325                               h_list_new = (struct elf_link_hash_entry_list *)
15326                                 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15327                               h_list->next = h_list_new;
15328                               h_list_new->h = h;
15329                               h_list_new->next = NULL;
15330                             }
15331                           break;
15332                         }
15333                       /* The sethi case may have different address but the
15334                          hi20 is the same.  */
15335                       else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15336                                && m_list->next == NULL)
15337                         {
15338                           struct elf_link_hash_entry_mul_list *m_list_new;
15339                           struct elf_link_hash_entry_list *h_list_new;
15340
15341                           m_list_new = (struct elf_link_hash_entry_mul_list *)
15342                             bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15343                           h_list_new = (struct elf_link_hash_entry_list *)
15344                             bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15345                           m_list->next = m_list_new;
15346                           m_list_new->h_list = h_list_new;
15347                           m_list_new->rel_backup = rel_backup;
15348                           m_list_new->times = 1;
15349                           m_list_new->irel = jrel;
15350                           m_list_new->next = NULL;
15351                           h_list_new->h = h;
15352                           h_list_new->next = NULL;
15353                           break;
15354                         }
15355                       m_list = m_list->next;
15356                     }
15357                   if (!m_list)
15358                     {
15359                       off += 4;
15360                       continue;
15361                     }
15362                 }
15363             }
15364           else
15365             {
15366               /* Local symbol and insn without relocation*/
15367               entry->times++;
15368               entry->rel_backup = rel_backup;
15369             }
15370
15371           /* Use in sethi insn with constant and global symbol in same format.  */
15372           if (!jrel)
15373             entry->const_insn = 1;
15374           else
15375             entry->irel = jrel;
15376           entry->sec = isec;
15377           off += 4;
15378         }
15379     }
15380   return TRUE;
15381 }
15382
15383 /* Set the _ITB_BASE, and point it to ex9 table.  */
15384
15385 bfd_boolean
15386 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15387 {
15388   bfd *abfd;
15389   asection *sec;
15390   bfd *output_bfd = NULL;
15391   struct bfd_link_hash_entry *bh = NULL;
15392
15393   if (is_ITB_BASE_set == 1)
15394     return TRUE;
15395
15396   is_ITB_BASE_set = 1;
15397
15398   bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15399
15400   if (bh && (bh->type == bfd_link_hash_defined
15401              || bh->type == bfd_link_hash_defweak))
15402     return TRUE;
15403
15404   for (abfd = link_info->input_bfds; abfd != NULL;
15405        abfd = abfd->link.next)
15406     {
15407       sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15408       if (sec != NULL)
15409         {
15410           output_bfd = sec->output_section->owner;
15411           break;
15412         }
15413     }
15414   if (output_bfd == NULL)
15415     {
15416       output_bfd = link_info->output_bfd;
15417       if (output_bfd->sections == NULL)
15418         return TRUE;
15419       else
15420         sec = bfd_abs_section_ptr;
15421     }
15422   bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15423                              FALSE, FALSE, TRUE);
15424   return (_bfd_generic_link_add_one_symbol
15425           (link_info, output_bfd, "_ITB_BASE_",
15426            BSF_GLOBAL | BSF_WEAK, sec, 0,
15427            (const char *) NULL, FALSE, get_elf_backend_data
15428            (output_bfd)->collect, &bh));
15429 } /* End EX9.IT  */
15430 \f
15431
15432 #define ELF_ARCH                                bfd_arch_nds32
15433 #define ELF_MACHINE_CODE                        EM_NDS32
15434 #define ELF_MAXPAGESIZE                         0x1000
15435 #define ELF_TARGET_ID                           NDS32_ELF_DATA
15436
15437 #define TARGET_BIG_SYM                          nds32_elf32_be_vec
15438 #define TARGET_BIG_NAME                         "elf32-nds32be"
15439 #define TARGET_LITTLE_SYM                       nds32_elf32_le_vec
15440 #define TARGET_LITTLE_NAME                      "elf32-nds32le"
15441
15442 #define elf_info_to_howto                       nds32_info_to_howto
15443 #define elf_info_to_howto_rel                   nds32_info_to_howto_rel
15444
15445 #define bfd_elf32_bfd_link_hash_table_create    nds32_elf_link_hash_table_create
15446 #define bfd_elf32_bfd_merge_private_bfd_data    nds32_elf_merge_private_bfd_data
15447 #define bfd_elf32_bfd_print_private_bfd_data    nds32_elf_print_private_bfd_data
15448 #define bfd_elf32_bfd_relax_section             nds32_elf_relax_section
15449 #define bfd_elf32_bfd_set_private_flags         nds32_elf_set_private_flags
15450
15451 #define bfd_elf32_mkobject                      nds32_elf_mkobject
15452 #define elf_backend_action_discarded            nds32_elf_action_discarded
15453 #define elf_backend_add_symbol_hook             nds32_elf_add_symbol_hook
15454 #define elf_backend_check_relocs                nds32_elf_check_relocs
15455 #define elf_backend_adjust_dynamic_symbol       nds32_elf_adjust_dynamic_symbol
15456 #define elf_backend_create_dynamic_sections     nds32_elf_create_dynamic_sections
15457 #define elf_backend_finish_dynamic_sections     nds32_elf_finish_dynamic_sections
15458 #define elf_backend_finish_dynamic_symbol       nds32_elf_finish_dynamic_symbol
15459 #define elf_backend_size_dynamic_sections       nds32_elf_size_dynamic_sections
15460 #define elf_backend_relocate_section            nds32_elf_relocate_section
15461 #define elf_backend_gc_mark_hook                nds32_elf_gc_mark_hook
15462 #define elf_backend_grok_prstatus               nds32_elf_grok_prstatus
15463 #define elf_backend_grok_psinfo                 nds32_elf_grok_psinfo
15464 #define elf_backend_reloc_type_class            nds32_elf_reloc_type_class
15465 #define elf_backend_copy_indirect_symbol        nds32_elf_copy_indirect_symbol
15466 #define elf_backend_link_output_symbol_hook     nds32_elf_output_symbol_hook
15467 #define elf_backend_output_arch_syms            nds32_elf_output_arch_syms
15468 #define elf_backend_object_p                    nds32_elf_object_p
15469 #define elf_backend_final_write_processing      nds32_elf_final_write_processing
15470 #define elf_backend_special_sections            nds32_elf_special_sections
15471 #define bfd_elf32_bfd_get_relocated_section_contents \
15472                                 nds32_elf_get_relocated_section_contents
15473
15474 #define elf_backend_can_gc_sections             1
15475 #define elf_backend_can_refcount                1
15476 #define elf_backend_want_got_plt                1
15477 #define elf_backend_plt_readonly                1
15478 #define elf_backend_want_plt_sym                0
15479 #define elf_backend_got_header_size             12
15480 #define elf_backend_may_use_rel_p               1
15481 #define elf_backend_default_use_rela_p          1
15482 #define elf_backend_may_use_rela_p              1
15483 #define elf_backend_dtrel_excludes_plt          1
15484
15485 #include "elf32-target.h"
15486
15487 #undef ELF_MAXPAGESIZE
15488 #define ELF_MAXPAGESIZE                         0x2000
15489
15490 #undef TARGET_BIG_SYM
15491 #define TARGET_BIG_SYM                          nds32_elf32_linux_be_vec
15492 #undef TARGET_BIG_NAME
15493 #define TARGET_BIG_NAME                         "elf32-nds32be-linux"
15494 #undef TARGET_LITTLE_SYM
15495 #define TARGET_LITTLE_SYM                       nds32_elf32_linux_le_vec
15496 #undef TARGET_LITTLE_NAME
15497 #define TARGET_LITTLE_NAME                      "elf32-nds32le-linux"
15498 #undef elf32_bed
15499 #define elf32_bed                               elf32_nds32_lin_bed
15500
15501 #include "elf32-target.h"