bfd/elf32-nds32.c

   1 /* NDS32-specific support for 32-bit ELF.
   2    Copyright (C) 2012-2015 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 static void nds32_elf_relocate_hi20
  60   (bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
  61 static reloc_howto_type *bfd_elf32_bfd_reloc_type_table_lookup
  62   (enum elf_nds32_reloc_type);
  63 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  64   (bfd *, bfd_reloc_code_real_type);
  65
  66 /* Target hooks.  */
  67 static void nds32_info_to_howto_rel
  68   (bfd *, arelent *, Elf_Internal_Rela *dst);
  69 static void nds32_info_to_howto
  70   (bfd *, arelent *, Elf_Internal_Rela *dst);
  71 static bfd_boolean nds32_elf_add_symbol_hook
  72   (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
  73    flagword *, asection **, bfd_vma *);
  74 static bfd_boolean nds32_elf_relocate_section
  75   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  76    Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
  77 static bfd_boolean nds32_elf_object_p (bfd *);
  78 static void nds32_elf_final_write_processing (bfd *, bfd_boolean);
  79 static bfd_boolean nds32_elf_set_private_flags (bfd *, flagword);
  80 static bfd_boolean nds32_elf_merge_private_bfd_data (bfd *, bfd *);
  81 static bfd_boolean nds32_elf_print_private_bfd_data (bfd *, void *);
  82 static bfd_boolean nds32_elf_gc_sweep_hook
  83   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  84 static bfd_boolean nds32_elf_check_relocs
  85   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  86 static asection *nds32_elf_gc_mark_hook
  87   (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  88    struct elf_link_hash_entry *, Elf_Internal_Sym *);
  89 static bfd_boolean nds32_elf_adjust_dynamic_symbol
  90   (struct bfd_link_info *, struct elf_link_hash_entry *);
  91 static bfd_boolean nds32_elf_size_dynamic_sections
  92   (bfd *, struct bfd_link_info *);
  93 static bfd_boolean nds32_elf_create_dynamic_sections
  94   (bfd *, struct bfd_link_info *);
  95 static bfd_boolean nds32_elf_finish_dynamic_sections
  96   (bfd *, struct bfd_link_info *info);
  97 static bfd_boolean nds32_elf_finish_dynamic_symbol
  98   (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  99    Elf_Internal_Sym *);
 100 static bfd_boolean nds32_elf_mkobject (bfd *);
 101
 102 /* Nds32 helper functions.  */
 103 static bfd_reloc_status_type nds32_elf_final_sda_base
 104   (bfd *, struct bfd_link_info *, bfd_vma *, bfd_boolean);
 105 static bfd_boolean allocate_dynrelocs (struct elf_link_hash_entry *, void *);
 106 static bfd_boolean readonly_dynrelocs (struct elf_link_hash_entry *, void *);
 107 static Elf_Internal_Rela *find_relocs_at_address
 108   (Elf_Internal_Rela *, Elf_Internal_Rela *,
 109    Elf_Internal_Rela *, enum elf_nds32_reloc_type);
 110 static bfd_vma calculate_memory_address
 111 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
 112 static int nds32_get_section_contents (bfd *, asection *,
 113                                        bfd_byte **, bfd_boolean);
 114 static bfd_boolean nds32_elf_ex9_build_hash_table
 115 (bfd *, asection *, struct bfd_link_info *);
 116 static bfd_boolean nds32_elf_ex9_itb_base (struct bfd_link_info *);
 117 static void nds32_elf_ex9_import_table (struct bfd_link_info *);
 118 static void nds32_elf_ex9_finish (struct bfd_link_info *);
 119 static void nds32_elf_ex9_reloc_jmp (struct bfd_link_info *);
 120 static void nds32_elf_get_insn_with_reg
 121   (Elf_Internal_Rela *, uint32_t, uint32_t *);
 122 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
 123                                  Elf_Internal_Sym **);
 124 static bfd_boolean nds32_elf_ex9_replace_instruction
 125   (struct bfd_link_info *, bfd *, asection *);
 126 static bfd_boolean nds32_elf_ifc_calc (struct bfd_link_info *, bfd *,
 127                                        asection *);
 128 static bfd_boolean nds32_elf_ifc_finish (struct bfd_link_info *);
 129 static bfd_boolean nds32_elf_ifc_replace (struct bfd_link_info *);
 130 static bfd_boolean nds32_elf_ifc_reloc (void);
 131 static bfd_boolean  nds32_relax_fp_as_gp
 132   (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
 133    Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
 134    Elf_Internal_Sym *isymbuf);
 135 static bfd_boolean nds32_fag_remove_unused_fpbase
 136   (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
 137    Elf_Internal_Rela *irelend);
 138 static bfd_byte *
 139 nds32_elf_get_relocated_section_contents (bfd *abfd,
 140                                           struct bfd_link_info *link_info,
 141                                           struct bfd_link_order *link_order,
 142                                           bfd_byte *data,
 143                                           bfd_boolean relocatable,
 144                                           asymbol **symbols);
 145
 146 enum
 147 {
 148   MACH_V1 = bfd_mach_n1h,
 149   MACH_V2 = bfd_mach_n1h_v2,
 150   MACH_V3 = bfd_mach_n1h_v3,
 151   MACH_V3M = bfd_mach_n1h_v3m
 152 };
 153
 154 #define MIN(a, b) ((a) > (b) ? (b) : (a))
 155 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 156
 157 /* The name of the dynamic interpreter.  This is put in the .interp
 158    section.  */
 159 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 160
 161 /* The nop opcode we use.  */
 162 #define NDS32_NOP32 0x40000009
 163 #define NDS32_NOP16 0x9200
 164
 165 /* The size in bytes of an entry in the procedure linkage table.  */
 166 #define PLT_ENTRY_SIZE 24
 167 #define PLT_HEADER_SIZE 24
 168
 169 /* The first entry in a procedure linkage table are reserved,
 170    and the initial contents are unimportant (we zero them out).
 171    Subsequent entries look like this.  */
 172 #define PLT0_ENTRY_WORD0  0x46f00000            /* sethi   r15, HI20(.got+4)      */
 173 #define PLT0_ENTRY_WORD1  0x58f78000            /* ori     r15, r25, LO12(.got+4) */
 174 #define PLT0_ENTRY_WORD2  0x05178000            /* lwi     r17, [r15+0]           */
 175 #define PLT0_ENTRY_WORD3  0x04f78001            /* lwi     r15, [r15+4]           */
 176 #define PLT0_ENTRY_WORD4  0x4a003c00            /* jr      r15                    */
 177
 178 /* $ta is change to $r15 (from $r25).  */
 179 #define PLT0_PIC_ENTRY_WORD0  0x46f00000        /* sethi   r15, HI20(got[1]@GOT)  */
 180 #define PLT0_PIC_ENTRY_WORD1  0x58f78000        /* ori     r15, r15, LO12(got[1]@GOT) */
 181 #define PLT0_PIC_ENTRY_WORD2  0x40f7f400        /* add     r15, gp, r15           */
 182 #define PLT0_PIC_ENTRY_WORD3  0x05178000        /* lwi     r17, [r15+0]           */
 183 #define PLT0_PIC_ENTRY_WORD4  0x04f78001        /* lwi     r15, [r15+4]           */
 184 #define PLT0_PIC_ENTRY_WORD5  0x4a003c00        /* jr      r15                    */
 185
 186 #define PLT_ENTRY_WORD0  0x46f00000             /* sethi   r15, HI20(&got[n+3])      */
 187 #define PLT_ENTRY_WORD1  0x04f78000             /* lwi     r15, r15, LO12(&got[n+3]) */
 188 #define PLT_ENTRY_WORD2  0x4a003c00             /* jr      r15                       */
 189 #define PLT_ENTRY_WORD3  0x45000000             /* movi    r16, sizeof(RELA) * n     */
 190 #define PLT_ENTRY_WORD4  0x48000000             /* j      .plt0.                     */
 191
 192 #define PLT_PIC_ENTRY_WORD0  0x46f00000         /* sethi  r15, HI20(got[n+3]@GOT)    */
 193 #define PLT_PIC_ENTRY_WORD1  0x58f78000         /* ori    r15, r15,    LO12(got[n+3]@GOT) */
 194 #define PLT_PIC_ENTRY_WORD2  0x38febc02         /* lw     r15, [gp+r15]              */
 195 #define PLT_PIC_ENTRY_WORD3  0x4a003c00         /* jr     r15                        */
 196 #define PLT_PIC_ENTRY_WORD4  0x45000000         /* movi   r16, sizeof(RELA) * n      */
 197 #define PLT_PIC_ENTRY_WORD5  0x48000000         /* j      .plt0                      */
 198
 199 /* These are macros used to get the relocation accurate value.  */
 200 #define ACCURATE_8BIT_S1        (0x100)
 201 #define ACCURATE_U9BIT_S1       (0x400)
 202 #define ACCURATE_12BIT_S1       (0x2000)
 203 #define ACCURATE_14BIT_S1       (0x4000)
 204 #define ACCURATE_19BIT          (0x40000)
 205
 206 /* These are macros used to get the relocation conservative value.  */
 207 #define CONSERVATIVE_8BIT_S1    (0x100 - 4)
 208 #define CONSERVATIVE_14BIT_S1   (0x4000 - 4)
 209 #define CONSERVATIVE_16BIT_S1   (0x10000 - 4)
 210 #define CONSERVATIVE_24BIT_S1   (0x1000000 - 4)
 211 /* These must be more conservative because the address may be in
 212    different segment.  */
 213 #define CONSERVATIVE_15BIT      (0x4000 - 0x1000)
 214 #define CONSERVATIVE_15BIT_S1   (0x8000 - 0x1000)
 215 #define CONSERVATIVE_15BIT_S2   (0x10000 - 0x1000)
 216 #define CONSERVATIVE_19BIT      (0x40000 - 0x1000)
 217 #define CONSERVATIVE_20BIT      (0x80000 - 0x1000)
 218
 219 /* Size of small data/bss sections, used to calculate SDA_BASE.  */
 220 static long got_size = 0;
 221 static int is_SDA_BASE_set = 0;
 222 static int is_ITB_BASE_set = 0;
 223
 224 /* Convert ELF-VER in eflags to string for debugging purpose.  */
 225 static const char *const nds32_elfver_strtab[] =
 226 {
 227   "ELF-1.2",
 228   "ELF-1.3",
 229   "ELF-1.4",
 230 };
 231
 232 /* The nds32 linker needs to keep track of the number of relocs that it
 233    decides to copy in check_relocs for each symbol.  This is so that
 234    it can discard PC relative relocs if it doesn't need them when
 235    linking with -Bsymbolic.  We store the information in a field
 236    extending the regular ELF linker hash table.  */
 237
 238 /* This structure keeps track of the number of PC relative relocs we
 239    have copied for a given symbol.  */
 240
 241 struct elf_nds32_pcrel_relocs_copied
 242 {
 243   /* Next section.  */
 244   struct elf_nds32_pcrel_relocs_copied *next;
 245   /* A section in dynobj.  */
 246   asection *section;
 247   /* Number of relocs copied in this section.  */
 248   bfd_size_type count;
 249 };
 250
 251 /* The sh linker needs to keep track of the number of relocs that it
 252    decides to copy as dynamic relocs in check_relocs for each symbol.
 253    This is so that it can later discard them if they are found to be
 254    unnecessary.  We store the information in a field extending the
 255    regular ELF linker hash table.  */
 256
 257 struct elf_nds32_dyn_relocs
 258 {
 259   struct elf_nds32_dyn_relocs *next;
 260
 261   /* The input section of the reloc.  */
 262   asection *sec;
 263
 264   /* Total number of relocs copied for the input section.  */
 265   bfd_size_type count;
 266
 267   /* Number of pc-relative relocs copied for the input section.  */
 268   bfd_size_type pc_count;
 269 };
 270
 271 /* Nds32 ELF linker hash entry.  */
 272
 273 struct elf_nds32_link_hash_entry
 274 {
 275   struct elf_link_hash_entry root;
 276
 277   /* Track dynamic relocs copied for this symbol.  */
 278   struct elf_nds32_dyn_relocs *dyn_relocs;
 279
 280   /* For checking relocation type.  */
 281 #define GOT_UNKNOWN     0
 282 #define GOT_NORMAL      1
 283 #define GOT_TLS_IE      2
 284   unsigned int tls_type;
 285 };
 286
 287 /* Get the nds32 ELF linker hash table from a link_info structure.  */
 288
 289 #define FP_BASE_NAME "_FP_BASE_"
 290 static int check_start_export_sym = 0;
 291 static size_t ex9_relax_size = 0;               /* Save ex9 predicted reducing size.  */
 292
 293 /* The offset for executable tls relaxation.  */
 294 #define TP_OFFSET 0x0
 295
 296 struct elf_nds32_obj_tdata
 297 {
 298   struct elf_obj_tdata root;
 299
 300   /* tls_type for each local got entry.  */
 301   char *local_got_tls_type;
 302 };
 303
 304 #define elf_nds32_tdata(bfd) \
 305   ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
 306
 307 #define elf32_nds32_local_got_tls_type(bfd) \
 308   (elf_nds32_tdata (bfd)->local_got_tls_type)
 309
 310 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
 311
 312 static bfd_boolean
 313 nds32_elf_mkobject (bfd *abfd)
 314 {
 315   return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
 316                                   NDS32_ELF_DATA);
 317 }
 318
 319 /* Relocations used for relocation.  */
 320 static reloc_howto_type nds32_elf_howto_table[] =
 321 {
 322   /* This reloc does nothing.  */
 323   HOWTO (R_NDS32_NONE,          /* type */
 324          0,                     /* rightshift */
 325          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          0,                     /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_dont,        /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_NDS32_NONE",        /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0,                     /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* A 16 bit absolute relocation.  */
 338   HOWTO (R_NDS32_16,            /* type */
 339          0,                     /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield,    /* complain_on_overflow */
 345          nds32_elf_generic_reloc,       /* special_function */
 346          "R_NDS32_16",          /* name */
 347          FALSE,                 /* partial_inplace */
 348          0xffff,                /* src_mask */
 349          0xffff,                /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* A 32 bit absolute relocation.  */
 353   HOWTO (R_NDS32_32,            /* type */
 354          0,                     /* rightshift */
 355          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 356          32,                    /* bitsize */
 357          FALSE,                 /* pc_relative */
 358          0,                     /* bitpos */
 359          complain_overflow_bitfield,    /* complain_on_overflow */
 360          nds32_elf_generic_reloc,       /* special_function */
 361          "R_NDS32_32",          /* name */
 362          FALSE,                 /* partial_inplace */
 363          0xffffffff,            /* src_mask */
 364          0xffffffff,            /* dst_mask */
 365          FALSE),                /* pcrel_offset */
 366
 367   /* A 20 bit address.  */
 368   HOWTO (R_NDS32_20,            /* type */
 369          0,                     /* rightshift */
 370          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 371          20,                    /* bitsize */
 372          FALSE,                 /* pc_relative */
 373          0,                     /* bitpos */
 374          complain_overflow_unsigned,    /* complain_on_overflow */
 375          nds32_elf_generic_reloc,       /* special_function */
 376          "R_NDS32_20",          /* name */
 377          FALSE,                 /* partial_inplace */
 378          0xfffff,               /* src_mask */
 379          0xfffff,               /* dst_mask */
 380          FALSE),                /* pcrel_offset */
 381
 382   /* An PC Relative 9-bit relocation, shifted by 2.
 383      This reloc is complicated because relocations are relative to pc & -4.
 384      i.e. branches in the right insn slot use the address of the left insn
 385      slot for pc.  */
 386   /* ??? It's not clear whether this should have partial_inplace set or not.
 387      Branch relaxing in the assembler can store the addend in the insn,
 388      and if bfd_install_relocation gets called the addend may get added
 389      again.  */
 390   HOWTO (R_NDS32_9_PCREL,       /* type */
 391          1,                     /* rightshift */
 392          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 393          8,                     /* bitsize */
 394          TRUE,                  /* pc_relative */
 395          0,                     /* bitpos */
 396          complain_overflow_signed,      /* complain_on_overflow */
 397          nds32_elf_9_pcrel_reloc,       /* special_function */
 398          "R_NDS32_9_PCREL",     /* name */
 399          FALSE,                 /* partial_inplace */
 400          0xff,                  /* src_mask */
 401          0xff,                  /* dst_mask */
 402          TRUE),                 /* pcrel_offset */
 403
 404   /* A relative 15 bit relocation, right shifted by 1.  */
 405   HOWTO (R_NDS32_15_PCREL,      /* type */
 406          1,                     /* rightshift */
 407          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 408          14,                    /* bitsize */
 409          TRUE,                  /* pc_relative */
 410          0,                     /* bitpos */
 411          complain_overflow_signed,      /* complain_on_overflow */
 412          bfd_elf_generic_reloc, /* special_function */
 413          "R_NDS32_15_PCREL",    /* name */
 414          FALSE,                 /* partial_inplace */
 415          0x3fff,                /* src_mask */
 416          0x3fff,                /* dst_mask */
 417          TRUE),                 /* pcrel_offset */
 418
 419   /* A relative 17 bit relocation, right shifted by 1.  */
 420   HOWTO (R_NDS32_17_PCREL,      /* type */
 421          1,                     /* rightshift */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          TRUE,                  /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed,      /* complain_on_overflow */
 427          bfd_elf_generic_reloc, /* special_function */
 428          "R_NDS32_17_PCREL",    /* name */
 429          FALSE,                 /* partial_inplace */
 430          0xffff,                /* src_mask */
 431          0xffff,                /* dst_mask */
 432          TRUE),                 /* pcrel_offset */
 433
 434   /* A relative 25 bit relocation, right shifted by 1.  */
 435   /* ??? It's not clear whether this should have partial_inplace set or not.
 436      Branch relaxing in the assembler can store the addend in the insn,
 437      and if bfd_install_relocation gets called the addend may get added
 438      again.  */
 439   HOWTO (R_NDS32_25_PCREL,      /* type */
 440          1,                     /* rightshift */
 441          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 442          24,                    /* bitsize */
 443          TRUE,                  /* pc_relative */
 444          0,                     /* bitpos */
 445          complain_overflow_signed,      /* complain_on_overflow */
 446          bfd_elf_generic_reloc, /* special_function */
 447          "R_NDS32_25_PCREL",    /* name */
 448          FALSE,                 /* partial_inplace */
 449          0xffffff,              /* src_mask */
 450          0xffffff,              /* dst_mask */
 451          TRUE),                 /* pcrel_offset */
 452
 453   /* High 20 bits of address when lower 12 is or'd in.  */
 454   HOWTO (R_NDS32_HI20,          /* type */
 455          12,                    /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          20,                    /* bitsize */
 458          FALSE,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_dont,/* complain_on_overflow */
 461          nds32_elf_hi20_reloc,  /* special_function */
 462          "R_NDS32_HI20",        /* name */
 463          FALSE,                 /* partial_inplace */
 464          0x000fffff,            /* src_mask */
 465          0x000fffff,            /* dst_mask */
 466          FALSE),                /* pcrel_offset */
 467
 468   /* Lower 12 bits of address.  */
 469   HOWTO (R_NDS32_LO12S3,        /* type */
 470          3,                     /* rightshift */
 471          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          9,                     /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_dont,/* complain_on_overflow */
 476          nds32_elf_lo12_reloc,  /* special_function */
 477          "R_NDS32_LO12S3",      /* name */
 478          FALSE,                 /* partial_inplace */
 479          0x000001ff,            /* src_mask */
 480          0x000001ff,            /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Lower 12 bits of address.  */
 484   HOWTO (R_NDS32_LO12S2,        /* type */
 485          2,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          10,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont,/* complain_on_overflow */
 491          nds32_elf_lo12_reloc,  /* special_function */
 492          "R_NDS32_LO12S2",      /* name */
 493          FALSE,                 /* partial_inplace */
 494          0x000003ff,            /* src_mask */
 495          0x000003ff,            /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Lower 12 bits of address.  */
 499   HOWTO (R_NDS32_LO12S1,        /* type */
 500          1,                     /* rightshift */
 501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          11,                    /* bitsize */
 503          FALSE,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_dont,/* complain_on_overflow */
 506          nds32_elf_lo12_reloc,  /* special_function */
 507          "R_NDS32_LO12S1",      /* name */
 508          FALSE,                 /* partial_inplace */
 509          0x000007ff,            /* src_mask */
 510          0x000007ff,            /* dst_mask */
 511          FALSE),                /* pcrel_offset */
 512
 513   /* Lower 12 bits of address.  */
 514   HOWTO (R_NDS32_LO12S0,        /* type */
 515          0,                     /* rightshift */
 516          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 517          12,                    /* bitsize */
 518          FALSE,                 /* pc_relative */
 519          0,                     /* bitpos */
 520          complain_overflow_dont,/* complain_on_overflow */
 521          nds32_elf_lo12_reloc,  /* special_function */
 522          "R_NDS32_LO12S0",      /* name */
 523          FALSE,                 /* partial_inplace */
 524          0x00000fff,            /* src_mask */
 525          0x00000fff,            /* dst_mask */
 526          FALSE),                /* pcrel_offset */
 527
 528   /* Small data area 15 bits offset.  */
 529   HOWTO (R_NDS32_SDA15S3,       /* type */
 530          3,                     /* rightshift */
 531          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 532          15,                    /* bitsize */
 533          FALSE,                 /* pc_relative */
 534          0,                     /* bitpos */
 535          complain_overflow_signed,      /* complain_on_overflow */
 536          nds32_elf_sda15_reloc, /* special_function */
 537          "R_NDS32_SDA15S3",     /* name */
 538          FALSE,                 /* partial_inplace */
 539          0x00007fff,            /* src_mask */
 540          0x00007fff,            /* dst_mask */
 541          FALSE),                /* pcrel_offset */
 542
 543   /* Small data area 15 bits offset.  */
 544   HOWTO (R_NDS32_SDA15S2,       /* type */
 545          2,                     /* rightshift */
 546          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          15,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,      /* complain_on_overflow */
 551          nds32_elf_sda15_reloc, /* special_function */
 552          "R_NDS32_SDA15S2",     /* name */
 553          FALSE,                 /* partial_inplace */
 554          0x00007fff,            /* src_mask */
 555          0x00007fff,            /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* Small data area 15 bits offset.  */
 559   HOWTO (R_NDS32_SDA15S1,       /* type */
 560          1,                     /* rightshift */
 561          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 562          15,                    /* bitsize */
 563          FALSE,                 /* pc_relative */
 564          0,                     /* bitpos */
 565          complain_overflow_signed,      /* complain_on_overflow */
 566          nds32_elf_sda15_reloc, /* special_function */
 567          "R_NDS32_SDA15S1",     /* name */
 568          FALSE,                 /* partial_inplace */
 569          0x00007fff,            /* src_mask */
 570          0x00007fff,            /* dst_mask */
 571          FALSE),                /* pcrel_offset */
 572
 573   /* Small data area 15 bits offset.  */
 574   HOWTO (R_NDS32_SDA15S0,       /* type */
 575          0,                     /* rightshift */
 576          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 577          15,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_signed,      /* complain_on_overflow */
 581          nds32_elf_sda15_reloc, /* special_function */
 582          "R_NDS32_SDA15S0",     /* name */
 583          FALSE,                 /* partial_inplace */
 584          0x00007fff,            /* src_mask */
 585          0x00007fff,            /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* GNU extension to record C++ vtable hierarchy */
 589   HOWTO (R_NDS32_GNU_VTINHERIT, /* type */
 590          0,                     /* rightshift */
 591          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 592          0,                     /* bitsize */
 593          FALSE,                 /* pc_relative */
 594          0,                     /* bitpos */
 595          complain_overflow_dont,/* complain_on_overflow */
 596          NULL,                  /* special_function */
 597          "R_NDS32_GNU_VTINHERIT",       /* name */
 598          FALSE,                 /* partial_inplace */
 599          0,                     /* src_mask */
 600          0,                     /* dst_mask */
 601          FALSE),                /* pcrel_offset */
 602
 603   /* GNU extension to record C++ vtable member usage */
 604   HOWTO (R_NDS32_GNU_VTENTRY,   /* type */
 605          0,                     /* rightshift */
 606          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 607          0,                     /* bitsize */
 608          FALSE,                 /* pc_relative */
 609          0,                     /* bitpos */
 610          complain_overflow_dont,/* complain_on_overflow */
 611          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 612          "R_NDS32_GNU_VTENTRY", /* name */
 613          FALSE,                 /* partial_inplace */
 614          0,                     /* src_mask */
 615          0,                     /* dst_mask */
 616          FALSE),                /* pcrel_offset */
 617
 618   /* A 16 bit absolute relocation.  */
 619   HOWTO (R_NDS32_16_RELA,       /* type */
 620          0,                     /* rightshift */
 621          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 622          16,                    /* bitsize */
 623          FALSE,                 /* pc_relative */
 624          0,                     /* bitpos */
 625          complain_overflow_bitfield,    /* complain_on_overflow */
 626          bfd_elf_generic_reloc, /* special_function */
 627          "R_NDS32_16_RELA",     /* name */
 628          FALSE,                 /* partial_inplace */
 629          0xffff,                /* src_mask */
 630          0xffff,                /* dst_mask */
 631          FALSE),                /* pcrel_offset */
 632
 633   /* A 32 bit absolute relocation.  */
 634   HOWTO (R_NDS32_32_RELA,       /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          FALSE,                 /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_bitfield,    /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_NDS32_32_RELA",     /* name */
 643          FALSE,                 /* partial_inplace */
 644          0xffffffff,            /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          FALSE),                /* pcrel_offset */
 647
 648   /* A 20 bit address.  */
 649   HOWTO (R_NDS32_20_RELA,       /* type */
 650          0,                     /* rightshift */
 651          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 652          20,                    /* bitsize */
 653          FALSE,                 /* pc_relative */
 654          0,                     /* bitpos */
 655          complain_overflow_signed,      /* complain_on_overflow */
 656          bfd_elf_generic_reloc, /* special_function */
 657          "R_NDS32_20_RELA",     /* name */
 658          FALSE,                 /* partial_inplace */
 659          0xfffff,               /* src_mask */
 660          0xfffff,               /* dst_mask */
 661          FALSE),                /* pcrel_offset */
 662
 663   HOWTO (R_NDS32_9_PCREL_RELA,  /* type */
 664          1,                     /* rightshift */
 665          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 666          8,                     /* bitsize */
 667          TRUE,                  /* pc_relative */
 668          0,                     /* bitpos */
 669          complain_overflow_signed,      /* complain_on_overflow */
 670          bfd_elf_generic_reloc, /* special_function */
 671          "R_NDS32_9_PCREL_RELA",/* name */
 672          FALSE,                 /* partial_inplace */
 673          0xff,                  /* src_mask */
 674          0xff,                  /* dst_mask */
 675          TRUE),                 /* pcrel_offset */
 676
 677   /* A relative 15 bit relocation, right shifted by 1.  */
 678   HOWTO (R_NDS32_15_PCREL_RELA, /* type */
 679          1,                     /* rightshift */
 680          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          14,                    /* bitsize */
 682          TRUE,                  /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_signed,      /* complain_on_overflow */
 685          bfd_elf_generic_reloc, /* special_function */
 686          "R_NDS32_15_PCREL_RELA",       /* name */
 687          FALSE,                 /* partial_inplace */
 688          0x3fff,                /* src_mask */
 689          0x3fff,                /* dst_mask */
 690          TRUE),                 /* pcrel_offset */
 691
 692   /* A relative 17 bit relocation, right shifted by 1.  */
 693   HOWTO (R_NDS32_17_PCREL_RELA, /* type */
 694          1,                     /* rightshift */
 695          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 696          16,                    /* bitsize */
 697          TRUE,                  /* pc_relative */
 698          0,                     /* bitpos */
 699          complain_overflow_signed,      /* complain_on_overflow */
 700          bfd_elf_generic_reloc, /* special_function */
 701          "R_NDS32_17_PCREL_RELA",       /* name */
 702          FALSE,                 /* partial_inplace */
 703          0xffff,                /* src_mask */
 704          0xffff,                /* dst_mask */
 705          TRUE),                 /* pcrel_offset */
 706
 707   /* A relative 25 bit relocation, right shifted by 2.  */
 708   HOWTO (R_NDS32_25_PCREL_RELA, /* type */
 709          1,                     /* rightshift */
 710          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          24,                    /* bitsize */
 712          TRUE,                  /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_signed,      /* complain_on_overflow */
 715          bfd_elf_generic_reloc, /* special_function */
 716          "R_NDS32_25_PCREL_RELA",       /* name */
 717          FALSE,                 /* partial_inplace */
 718          0xffffff,              /* src_mask */
 719          0xffffff,              /* dst_mask */
 720          TRUE),                 /* pcrel_offset */
 721
 722   /* High 20 bits of address when lower 16 is or'd in.  */
 723   HOWTO (R_NDS32_HI20_RELA,     /* type */
 724          12,                    /* rightshift */
 725          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          20,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_dont,/* complain_on_overflow */
 730          bfd_elf_generic_reloc, /* special_function */
 731          "R_NDS32_HI20_RELA",   /* name */
 732          FALSE,                 /* partial_inplace */
 733          0x000fffff,            /* src_mask */
 734          0x000fffff,            /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* Lower 12 bits of address.  */
 738   HOWTO (R_NDS32_LO12S3_RELA,   /* type */
 739          3,                     /* rightshift */
 740          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          9,                     /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont,/* complain_on_overflow */
 745          bfd_elf_generic_reloc, /* special_function */
 746          "R_NDS32_LO12S3_RELA", /* name */
 747          FALSE,                 /* partial_inplace */
 748          0x000001ff,            /* src_mask */
 749          0x000001ff,            /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* Lower 12 bits of address.  */
 753   HOWTO (R_NDS32_LO12S2_RELA,   /* type */
 754          2,                     /* rightshift */
 755          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          10,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_dont,/* complain_on_overflow */
 760          bfd_elf_generic_reloc, /* special_function */
 761          "R_NDS32_LO12S2_RELA", /* name */
 762          FALSE,                 /* partial_inplace */
 763          0x000003ff,            /* src_mask */
 764          0x000003ff,            /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* Lower 12 bits of address.  */
 768   HOWTO (R_NDS32_LO12S1_RELA,   /* type */
 769          1,                     /* rightshift */
 770          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          11,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont,/* complain_on_overflow */
 775          bfd_elf_generic_reloc, /* special_function */
 776          "R_NDS32_LO12S1_RELA", /* name */
 777          FALSE,                 /* partial_inplace */
 778          0x000007ff,            /* src_mask */
 779          0x000007ff,            /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* Lower 12 bits of address.  */
 783   HOWTO (R_NDS32_LO12S0_RELA,   /* type */
 784          0,                     /* rightshift */
 785          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          12,                    /* bitsize */
 787          FALSE,                 /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_dont,/* complain_on_overflow */
 790          bfd_elf_generic_reloc, /* special_function */
 791          "R_NDS32_LO12S0_RELA", /* name */
 792          FALSE,                 /* partial_inplace */
 793          0x00000fff,            /* src_mask */
 794          0x00000fff,            /* dst_mask */
 795          FALSE),                /* pcrel_offset */
 796
 797   /* Small data area 15 bits offset.  */
 798   HOWTO (R_NDS32_SDA15S3_RELA,  /* type */
 799          3,                     /* rightshift */
 800          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 801          15,                    /* bitsize */
 802          FALSE,                 /* pc_relative */
 803          0,                     /* bitpos */
 804          complain_overflow_signed,      /* complain_on_overflow */
 805          bfd_elf_generic_reloc, /* special_function */
 806          "R_NDS32_SDA15S3_RELA",/* name */
 807          FALSE,                 /* partial_inplace */
 808          0x00007fff,            /* src_mask */
 809          0x00007fff,            /* dst_mask */
 810          FALSE),                /* pcrel_offset */
 811
 812   /* Small data area 15 bits offset.  */
 813   HOWTO (R_NDS32_SDA15S2_RELA,  /* type */
 814          2,                     /* rightshift */
 815          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 816          15,                    /* bitsize */
 817          FALSE,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_signed,      /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_NDS32_SDA15S2_RELA",/* name */
 822          FALSE,                 /* partial_inplace */
 823          0x00007fff,            /* src_mask */
 824          0x00007fff,            /* dst_mask */
 825          FALSE),                /* pcrel_offset */
 826
 827   HOWTO (R_NDS32_SDA15S1_RELA,  /* type */
 828          1,                     /* rightshift */
 829          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 830          15,                    /* bitsize */
 831          FALSE,                 /* pc_relative */
 832          0,                     /* bitpos */
 833          complain_overflow_signed,      /* complain_on_overflow */
 834          bfd_elf_generic_reloc, /* special_function */
 835          "R_NDS32_SDA15S1_RELA",/* name */
 836          FALSE,                 /* partial_inplace */
 837          0x00007fff,            /* src_mask */
 838          0x00007fff,            /* dst_mask */
 839          FALSE),                /* pcrel_offset */
 840
 841   HOWTO (R_NDS32_SDA15S0_RELA,  /* type */
 842          0,                     /* rightshift */
 843          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 844          15,                    /* bitsize */
 845          FALSE,                 /* pc_relative */
 846          0,                     /* bitpos */
 847          complain_overflow_signed,      /* complain_on_overflow */
 848          bfd_elf_generic_reloc, /* special_function */
 849          "R_NDS32_SDA15S0_RELA",/* name */
 850          FALSE,                 /* partial_inplace */
 851          0x00007fff,            /* src_mask */
 852          0x00007fff,            /* dst_mask */
 853          FALSE),                /* pcrel_offset */
 854
 855   /* GNU extension to record C++ vtable hierarchy */
 856   HOWTO (R_NDS32_RELA_GNU_VTINHERIT,    /* type */
 857          0,                     /* rightshift */
 858          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 859          0,                     /* bitsize */
 860          FALSE,                 /* pc_relative */
 861          0,                     /* bitpos */
 862          complain_overflow_dont,/* complain_on_overflow */
 863          NULL,                  /* special_function */
 864          "R_NDS32_RELA_GNU_VTINHERIT",  /* name */
 865          FALSE,                 /* partial_inplace */
 866          0,                     /* src_mask */
 867          0,                     /* dst_mask */
 868          FALSE),                /* pcrel_offset */
 869
 870   /* GNU extension to record C++ vtable member usage */
 871   HOWTO (R_NDS32_RELA_GNU_VTENTRY,      /* type */
 872          0,                     /* rightshift */
 873          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 874          0,                     /* bitsize */
 875          FALSE,                 /* pc_relative */
 876          0,                     /* bitpos */
 877          complain_overflow_dont,/* complain_on_overflow */
 878          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 879          "R_NDS32_RELA_GNU_VTENTRY",    /* name */
 880          FALSE,                 /* partial_inplace */
 881          0,                     /* src_mask */
 882          0,                     /* dst_mask */
 883          FALSE),                /* pcrel_offset */
 884
 885   /* Like R_NDS32_20, but referring to the GOT table entry for
 886      the symbol.  */
 887   HOWTO (R_NDS32_GOT20,         /* type */
 888          0,                     /* rightshift */
 889          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 890          20,                    /* bitsize */
 891          FALSE,                 /* pc_relative */
 892          0,                     /* bitpos */
 893          complain_overflow_signed,      /* complain_on_overflow */
 894          bfd_elf_generic_reloc, /* special_function */
 895          "R_NDS32_GOT20",       /* name */
 896          FALSE,                 /* partial_inplace */
 897          0xfffff,               /* src_mask */
 898          0xfffff,               /* dst_mask */
 899          FALSE),                /* pcrel_offset */
 900
 901   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
 902      entry for the symbol.  */
 903   HOWTO (R_NDS32_25_PLTREL,     /* type */
 904          1,                     /* rightshift */
 905          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 906          24,                    /* bitsize */
 907          TRUE,                  /* pc_relative */
 908          0,                     /* bitpos */
 909          complain_overflow_signed,      /* complain_on_overflow */
 910          bfd_elf_generic_reloc, /* special_function */
 911          "R_NDS32_25_PLTREL",   /* name */
 912          FALSE,                 /* partial_inplace */
 913          0xffffff,              /* src_mask */
 914          0xffffff,              /* dst_mask */
 915          TRUE),                 /* pcrel_offset */
 916
 917   /* This is used only by the dynamic linker.  The symbol should exist
 918      both in the object being run and in some shared library.  The
 919      dynamic linker copies the data addressed by the symbol from the
 920      shared library into the object, because the object being
 921      run has to have the data at some particular address.  */
 922   HOWTO (R_NDS32_COPY,          /* type */
 923          0,                     /* rightshift */
 924          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 925          32,                    /* bitsize */
 926          FALSE,                 /* pc_relative */
 927          0,                     /* bitpos */
 928          complain_overflow_bitfield,    /* complain_on_overflow */
 929          bfd_elf_generic_reloc, /* special_function */
 930          "R_NDS32_COPY",        /* name */
 931          FALSE,                 /* partial_inplace */
 932          0xffffffff,            /* src_mask */
 933          0xffffffff,            /* dst_mask */
 934          FALSE),                /* pcrel_offset */
 935
 936   /* Like R_NDS32_20, but used when setting global offset table
 937      entries.  */
 938   HOWTO (R_NDS32_GLOB_DAT,      /* type */
 939          0,                     /* rightshift */
 940          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 941          32,                    /* bitsize */
 942          FALSE,                 /* pc_relative */
 943          0,                     /* bitpos */
 944          complain_overflow_bitfield,    /* complain_on_overflow */
 945          bfd_elf_generic_reloc, /* special_function */
 946          "R_NDS32_GLOB_DAT",    /* name */
 947          FALSE,                 /* partial_inplace */
 948          0xffffffff,            /* src_mask */
 949          0xffffffff,            /* dst_mask */
 950          FALSE),                /* pcrel_offset */
 951
 952   /* Marks a procedure linkage table entry for a symbol.  */
 953   HOWTO (R_NDS32_JMP_SLOT,      /* type */
 954          0,                     /* rightshift */
 955          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 956          32,                    /* bitsize */
 957          FALSE,                 /* pc_relative */
 958          0,                     /* bitpos */
 959          complain_overflow_bitfield,    /* complain_on_overflow */
 960          bfd_elf_generic_reloc, /* special_function */
 961          "R_NDS32_JMP_SLOT",    /* name */
 962          FALSE,                 /* partial_inplace */
 963          0xffffffff,            /* src_mask */
 964          0xffffffff,            /* dst_mask */
 965          FALSE),                /* pcrel_offset */
 966
 967   /* Used only by the dynamic linker.  When the object is run, this
 968      longword is set to the load address of the object, plus the
 969      addend.  */
 970   HOWTO (R_NDS32_RELATIVE,      /* type */
 971          0,                     /* rightshift */
 972          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 973          32,                    /* bitsize */
 974          FALSE,                 /* pc_relative */
 975          0,                     /* bitpos */
 976          complain_overflow_bitfield,    /* complain_on_overflow */
 977          bfd_elf_generic_reloc, /* special_function */
 978          "R_NDS32_RELATIVE",    /* name */
 979          FALSE,                 /* partial_inplace */
 980          0xffffffff,            /* src_mask */
 981          0xffffffff,            /* dst_mask */
 982          FALSE),                /* pcrel_offset */
 983
 984   HOWTO (R_NDS32_GOTOFF,        /* type */
 985          0,                     /* rightshift */
 986          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 987          20,                    /* bitsize */
 988          FALSE,                 /* pc_relative */
 989          0,                     /* bitpos */
 990          complain_overflow_signed,      /* complain_on_overflow */
 991          bfd_elf_generic_reloc, /* special_function */
 992          "R_NDS32_GOTOFF",      /* name */
 993          FALSE,                 /* partial_inplace */
 994          0xfffff,               /* src_mask */
 995          0xfffff,               /* dst_mask */
 996          FALSE),                /* pcrel_offset */
 997
 998   /* An PC Relative 20-bit relocation used when setting PIC offset
 999      table register.  */
1000   HOWTO (R_NDS32_GOTPC20,       /* type */
1001          0,                     /* rightshift */
1002          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1003          20,                    /* bitsize */
1004          TRUE,                  /* pc_relative */
1005          0,                     /* bitpos */
1006          complain_overflow_signed,      /* complain_on_overflow */
1007          bfd_elf_generic_reloc, /* special_function */
1008          "R_NDS32_GOTPC20",     /* name */
1009          FALSE,                 /* partial_inplace */
1010          0xfffff,               /* src_mask */
1011          0xfffff,               /* dst_mask */
1012          TRUE),                 /* pcrel_offset */
1013
1014   /* Like R_NDS32_HI20, but referring to the GOT table entry for
1015      the symbol.  */
1016   HOWTO (R_NDS32_GOT_HI20,      /* type */
1017          12,                    /* rightshift */
1018          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1019          20,                    /* bitsize */
1020          FALSE,                 /* pc_relative */
1021          0,                     /* bitpos */
1022          complain_overflow_dont,/* complain_on_overflow */
1023          bfd_elf_generic_reloc, /* special_function */
1024          "R_NDS32_GOT_HI20",    /* name */
1025          FALSE,                 /* partial_inplace */
1026          0x000fffff,            /* src_mask */
1027          0x000fffff,            /* dst_mask */
1028          FALSE),                /* pcrel_offset */
1029   HOWTO (R_NDS32_GOT_LO12,      /* type */
1030          0,                     /* rightshift */
1031          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1032          12,                    /* bitsize */
1033          FALSE,                 /* pc_relative */
1034          0,                     /* bitpos */
1035          complain_overflow_dont,/* complain_on_overflow */
1036          bfd_elf_generic_reloc, /* special_function */
1037          "R_NDS32_GOT_LO12",    /* name */
1038          FALSE,                 /* partial_inplace */
1039          0x00000fff,            /* src_mask */
1040          0x00000fff,            /* dst_mask */
1041          FALSE),                /* pcrel_offset */
1042
1043   /* An PC Relative relocation used when setting PIC offset table register.
1044      Like R_NDS32_HI20, but referring to the GOT table entry for
1045      the symbol.  */
1046   HOWTO (R_NDS32_GOTPC_HI20,    /* type */
1047          12,                    /* rightshift */
1048          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049          20,                    /* bitsize */
1050          FALSE,                 /* pc_relative */
1051          0,                     /* bitpos */
1052          complain_overflow_dont,/* complain_on_overflow */
1053          bfd_elf_generic_reloc, /* special_function */
1054          "R_NDS32_GOTPC_HI20",  /* name */
1055          FALSE,                 /* partial_inplace */
1056          0x000fffff,            /* src_mask */
1057          0x000fffff,            /* dst_mask */
1058          TRUE),                 /* pcrel_offset */
1059   HOWTO (R_NDS32_GOTPC_LO12,    /* type */
1060          0,                     /* rightshift */
1061          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1062          12,                    /* bitsize */
1063          FALSE,                 /* pc_relative */
1064          0,                     /* bitpos */
1065          complain_overflow_dont,        /* complain_on_overflow */
1066          bfd_elf_generic_reloc, /* special_function */
1067          "R_NDS32_GOTPC_LO12",  /* name */
1068          FALSE,                 /* partial_inplace */
1069          0x00000fff,            /* src_mask */
1070          0x00000fff,            /* dst_mask */
1071          TRUE),                 /* pcrel_offset */
1072
1073   HOWTO (R_NDS32_GOTOFF_HI20,   /* type */
1074          12,                    /* rightshift */
1075          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          20,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont,/* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_NDS32_GOTOFF_HI20", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0x000fffff,            /* src_mask */
1084          0x000fffff,            /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086   HOWTO (R_NDS32_GOTOFF_LO12,   /* type */
1087          0,                     /* rightshift */
1088          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1089          12,                    /* bitsize */
1090          FALSE,                 /* pc_relative */
1091          0,                     /* bitpos */
1092          complain_overflow_dont,/* complain_on_overflow */
1093          bfd_elf_generic_reloc, /* special_function */
1094          "R_NDS32_GOTOFF_LO12", /* name */
1095          FALSE,                 /* partial_inplace */
1096          0x00000fff,            /* src_mask */
1097          0x00000fff,            /* dst_mask */
1098          FALSE),                /* pcrel_offset */
1099
1100   /* Alignment hint for relaxable instruction.  This is used with
1101      R_NDS32_LABEL as a pair.  Relax this instruction from 4 bytes to 2
1102      in order to make next label aligned on word boundary.  */
1103   HOWTO (R_NDS32_INSN16,        /* type */
1104          0,                     /* rightshift */
1105          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          32,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_dont,/* complain_on_overflow */
1110          nds32_elf_ignore_reloc,/* special_function */
1111          "R_NDS32_INSN16",      /* name */
1112          FALSE,                 /* partial_inplace */
1113          0x00000fff,            /* src_mask */
1114          0x00000fff,            /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Alignment hint for label.  */
1118   HOWTO (R_NDS32_LABEL,         /* type */
1119          0,                     /* rightshift */
1120          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          32,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_dont,/* complain_on_overflow */
1125          nds32_elf_ignore_reloc,/* special_function */
1126          "R_NDS32_LABEL",       /* name */
1127          FALSE,                 /* partial_inplace */
1128          0xffffffff,            /* src_mask */
1129          0xffffffff,            /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Relax hint for unconditional call sequence  */
1133   HOWTO (R_NDS32_LONGCALL1,     /* type */
1134          0,                     /* rightshift */
1135          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          32,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont,/* complain_on_overflow */
1140          nds32_elf_ignore_reloc,/* special_function */
1141          "R_NDS32_LONGCALL1",   /* name */
1142          FALSE,                 /* partial_inplace */
1143          0xffffffff,            /* src_mask */
1144          0xffffffff,            /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Relax hint for conditional call sequence.  */
1148   HOWTO (R_NDS32_LONGCALL2,     /* type */
1149          0,                     /* rightshift */
1150          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          32,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_dont,/* complain_on_overflow */
1155          nds32_elf_ignore_reloc,/* special_function */
1156          "R_NDS32_LONGCALL2",   /* name */
1157          FALSE,                 /* partial_inplace */
1158          0xffffffff,            /* src_mask */
1159          0xffffffff,            /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Relax hint for conditional call sequence.  */
1163   HOWTO (R_NDS32_LONGCALL3,     /* type */
1164          0,                     /* rightshift */
1165          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          32,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont,/* complain_on_overflow */
1170          nds32_elf_ignore_reloc,/* special_function */
1171          "R_NDS32_LONGCALL3",   /* name */
1172          FALSE,                 /* partial_inplace */
1173          0xffffffff,            /* src_mask */
1174          0xffffffff,            /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Relax hint for unconditional branch sequence.  */
1178   HOWTO (R_NDS32_LONGJUMP1,     /* type */
1179          0,                     /* rightshift */
1180          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          32,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_dont,/* complain_on_overflow */
1185          nds32_elf_ignore_reloc,/* special_function */
1186          "R_NDS32_LONGJUMP1",   /* name */
1187          FALSE,                 /* partial_inplace */
1188          0xffffffff,            /* src_mask */
1189          0xffffffff,            /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Relax hint for conditional branch sequence.  */
1193   HOWTO (R_NDS32_LONGJUMP2,     /* type */
1194          0,                     /* rightshift */
1195          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          32,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont,/* complain_on_overflow */
1200          nds32_elf_ignore_reloc,/* special_function */
1201          "R_NDS32_LONGJUMP2",   /* name */
1202          FALSE,                 /* partial_inplace */
1203          0xffffffff,            /* src_mask */
1204          0xffffffff,            /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Relax hint for conditional branch sequence.  */
1208   HOWTO (R_NDS32_LONGJUMP3,     /* type */
1209          0,                     /* rightshift */
1210          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1211          32,                    /* bitsize */
1212          FALSE,                 /* pc_relative */
1213          0,                     /* bitpos */
1214          complain_overflow_dont,/* complain_on_overflow */
1215          nds32_elf_ignore_reloc,/* special_function */
1216          "R_NDS32_LONGJUMP3",   /* name */
1217          FALSE,                 /* partial_inplace */
1218          0xffffffff,            /* src_mask */
1219          0xffffffff,            /* dst_mask */
1220          FALSE),                /* pcrel_offset */
1221
1222   /* Relax hint for load/store sequence.   */
1223   HOWTO (R_NDS32_LOADSTORE,     /* type */
1224          0,                     /* rightshift */
1225          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1226          32,                    /* bitsize */
1227          FALSE,                 /* pc_relative */
1228          0,                     /* bitpos */
1229          complain_overflow_dont,/* complain_on_overflow */
1230          nds32_elf_ignore_reloc,/* special_function */
1231          "R_NDS32_LOADSTORE",   /* name */
1232          FALSE,                 /* partial_inplace */
1233          0xffffffff,            /* src_mask */
1234          0xffffffff,            /* dst_mask */
1235          FALSE),                /* pcrel_offset */
1236
1237   /* Relax hint for load/store sequence.  */
1238   HOWTO (R_NDS32_9_FIXED_RELA,  /* type */
1239          0,                     /* rightshift */
1240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1241          16,                    /* bitsize */
1242          FALSE,                 /* pc_relative */
1243          0,                     /* bitpos */
1244          complain_overflow_dont,/* complain_on_overflow */
1245          nds32_elf_ignore_reloc,/* special_function */
1246          "R_NDS32_9_FIXED_RELA",/* name */
1247          FALSE,                 /* partial_inplace */
1248          0x000000ff,            /* src_mask */
1249          0x000000ff,            /* dst_mask */
1250          FALSE),                /* pcrel_offset */
1251
1252   /* Relax hint for load/store sequence.  */
1253   HOWTO (R_NDS32_15_FIXED_RELA, /* type */
1254          0,                     /* rightshift */
1255          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1256          32,                    /* bitsize */
1257          FALSE,                 /* pc_relative */
1258          0,                     /* bitpos */
1259          complain_overflow_dont,/* complain_on_overflow */
1260          nds32_elf_ignore_reloc,/* special_function */
1261          "R_NDS32_15_FIXED_RELA",       /* name */
1262          FALSE,                 /* partial_inplace */
1263          0x00003fff,            /* src_mask */
1264          0x00003fff,            /* dst_mask */
1265          FALSE),                /* pcrel_offset */
1266
1267   /* Relax hint for load/store sequence.  */
1268   HOWTO (R_NDS32_17_FIXED_RELA, /* type */
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont,/* complain_on_overflow */
1275          nds32_elf_ignore_reloc,/* special_function */
1276          "R_NDS32_17_FIXED_RELA",       /* name */
1277          FALSE,                 /* partial_inplace */
1278          0x0000ffff,            /* src_mask */
1279          0x0000ffff,            /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   /* Relax hint for load/store sequence.  */
1283   HOWTO (R_NDS32_25_FIXED_RELA, /* type */
1284          0,                     /* rightshift */
1285          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1286          32,                    /* bitsize */
1287          FALSE,                 /* pc_relative */
1288          0,                     /* bitpos */
1289          complain_overflow_dont,/* complain_on_overflow */
1290          nds32_elf_ignore_reloc,/* special_function */
1291          "R_NDS32_25_FIXED_RELA",       /* name */
1292          FALSE,                 /* partial_inplace */
1293          0x00ffffff,            /* src_mask */
1294          0x00ffffff,            /* dst_mask */
1295          FALSE),                /* pcrel_offset */
1296
1297   /* High 20 bits of PLT symbol offset relative to PC.  */
1298   HOWTO (R_NDS32_PLTREL_HI20,   /* type */
1299          12,                    /* rightshift */
1300          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1301          20,                    /* bitsize */
1302          FALSE,                 /* pc_relative */
1303          0,                     /* bitpos */
1304          complain_overflow_dont,/* complain_on_overflow */
1305          bfd_elf_generic_reloc, /* special_function */
1306          "R_NDS32_PLTREL_HI20", /* name */
1307          FALSE,                 /* partial_inplace */
1308          0x000fffff,            /* src_mask */
1309          0x000fffff,            /* dst_mask */
1310          FALSE),                /* pcrel_offset */
1311
1312   /* Low 12 bits of PLT symbol offset relative to PC.  */
1313   HOWTO (R_NDS32_PLTREL_LO12,   /* type */
1314          0,                     /* rightshift */
1315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          12,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          0,                     /* bitpos */
1319          complain_overflow_dont,/* complain_on_overflow */
1320          bfd_elf_generic_reloc, /* special_function */
1321          "R_NDS32_PLTREL_LO12", /* name */
1322          FALSE,                 /* partial_inplace */
1323          0x00000fff,            /* src_mask */
1324          0x00000fff,            /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   /* High 20 bits of PLT symbol offset relative to GOT (GP).  */
1328   HOWTO (R_NDS32_PLT_GOTREL_HI20,       /* type */
1329          12,                    /* rightshift */
1330          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1331          20,                    /* bitsize */
1332          FALSE,                 /* pc_relative */
1333          0,                     /* bitpos */
1334          complain_overflow_dont,/* complain_on_overflow */
1335          bfd_elf_generic_reloc, /* special_function */
1336          "R_NDS32_PLT_GOTREL_HI20",     /* name */
1337          FALSE,                 /* partial_inplace */
1338          0x000fffff,            /* src_mask */
1339          0x000fffff,            /* dst_mask */
1340          FALSE),                /* pcrel_offset */
1341
1342   /* Low 12 bits of PLT symbol offset relative to GOT (GP).  */
1343   HOWTO (R_NDS32_PLT_GOTREL_LO12,       /* type */
1344          0,                     /* rightshift */
1345          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          12,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont,/* complain_on_overflow */
1350          bfd_elf_generic_reloc, /* special_function */
1351          "R_NDS32_PLT_GOTREL_LO12",     /* name */
1352          FALSE,                 /* partial_inplace */
1353          0x00000fff,            /* src_mask */
1354          0x00000fff,            /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* Small data area 12 bits offset.  */
1358   HOWTO (R_NDS32_SDA12S2_DP_RELA,       /* type */
1359          2,                     /* rightshift */
1360          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1361          12,                    /* bitsize */
1362          FALSE,                 /* pc_relative */
1363          0,                     /* bitpos */
1364          complain_overflow_signed,      /* complain_on_overflow */
1365          bfd_elf_generic_reloc, /* special_function */
1366          "R_NDS32_SDA12S2_DP_RELA",     /* name */
1367          FALSE,                 /* partial_inplace */
1368          0x00000fff,            /* src_mask */
1369          0x00000fff,            /* dst_mask */
1370          FALSE),                /* pcrel_offset */
1371
1372   /* Small data area 12 bits offset.  */
1373   HOWTO (R_NDS32_SDA12S2_SP_RELA,       /* type */
1374          2,                     /* rightshift */
1375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1376          12,                    /* bitsize */
1377          FALSE,                 /* pc_relative */
1378          0,                     /* bitpos */
1379          complain_overflow_signed,      /* complain_on_overflow */
1380          bfd_elf_generic_reloc, /* special_function */
1381          "R_NDS32_SDA12S2_SP_RELA",     /* name */
1382          FALSE,                 /* partial_inplace */
1383          0x00000fff,            /* src_mask */
1384          0x00000fff,            /* dst_mask */
1385          FALSE),                /* pcrel_offset */
1386   /* Lower 12 bits of address.  */
1387
1388   HOWTO (R_NDS32_LO12S2_DP_RELA,        /* type */
1389          2,                     /* rightshift */
1390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1391          10,                    /* bitsize */
1392          FALSE,                 /* pc_relative */
1393          0,                     /* bitpos */
1394          complain_overflow_dont,/* complain_on_overflow */
1395          bfd_elf_generic_reloc, /* special_function */
1396          "R_NDS32_LO12S2_DP_RELA",      /* name */
1397          FALSE,                 /* partial_inplace */
1398          0x000003ff,            /* src_mask */
1399          0x000003ff,            /* dst_mask */
1400          FALSE),                /* pcrel_offset */
1401
1402   /* Lower 12 bits of address.  */
1403   HOWTO (R_NDS32_LO12S2_SP_RELA,/* type */
1404          2,                     /* rightshift */
1405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1406          10,                    /* bitsize */
1407          FALSE,                 /* pc_relative */
1408          0,                     /* bitpos */
1409          complain_overflow_dont,/* complain_on_overflow */
1410          bfd_elf_generic_reloc, /* special_function */
1411          "R_NDS32_LO12S2_SP_RELA",      /* name */
1412          FALSE,                 /* partial_inplace */
1413          0x000003ff,            /* src_mask */
1414          0x000003ff,            /* dst_mask */
1415          FALSE),                /* pcrel_offset */
1416   /* Lower 12 bits of address.  Special identity for or case.  */
1417   HOWTO (R_NDS32_LO12S0_ORI_RELA,       /* type */
1418          0,                     /* rightshift */
1419          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          12,                    /* bitsize */
1421          FALSE,                 /* pc_relative */
1422          0,                     /* bitpos */
1423          complain_overflow_dont,/* complain_on_overflow */
1424          bfd_elf_generic_reloc, /* special_function */
1425          "R_NDS32_LO12S0_ORI_RELA",     /* name */
1426          FALSE,                 /* partial_inplace */
1427          0x00000fff,            /* src_mask */
1428          0x00000fff,            /* dst_mask */
1429          FALSE),                /* pcrel_offset */
1430   /* Small data area 19 bits offset.  */
1431   HOWTO (R_NDS32_SDA16S3_RELA,  /* type */
1432          3,                     /* rightshift */
1433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_signed,      /* complain_on_overflow */
1438          bfd_elf_generic_reloc, /* special_function */
1439          "R_NDS32_SDA16S3_RELA",/* name */
1440          FALSE,                 /* partial_inplace */
1441          0x0000ffff,            /* src_mask */
1442          0x0000ffff,            /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Small data area 15 bits offset.  */
1446   HOWTO (R_NDS32_SDA17S2_RELA,  /* type */
1447          2,                     /* rightshift */
1448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          17,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_signed,      /* complain_on_overflow */
1453          bfd_elf_generic_reloc, /* special_function */
1454          "R_NDS32_SDA17S2_RELA",/* name */
1455          FALSE,                 /* partial_inplace */
1456          0x0001ffff,            /* src_mask */
1457          0x0001ffff,            /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   HOWTO (R_NDS32_SDA18S1_RELA,  /* type */
1461          1,                     /* rightshift */
1462          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1463          18,                    /* bitsize */
1464          FALSE,                 /* pc_relative */
1465          0,                     /* bitpos */
1466          complain_overflow_signed,      /* complain_on_overflow */
1467          bfd_elf_generic_reloc, /* special_function */
1468          "R_NDS32_SDA18S1_RELA",/* name */
1469          FALSE,                 /* partial_inplace */
1470          0x0003ffff,            /* src_mask */
1471          0x0003ffff,            /* dst_mask */
1472          FALSE),                /* pcrel_offset */
1473
1474   HOWTO (R_NDS32_SDA19S0_RELA,  /* type */
1475          0,                     /* rightshift */
1476          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          19,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_signed,      /* complain_on_overflow */
1481          bfd_elf_generic_reloc, /* special_function */
1482          "R_NDS32_SDA19S0_RELA",/* name */
1483          FALSE,                 /* partial_inplace */
1484          0x0007ffff,            /* src_mask */
1485          0x0007ffff,            /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487   HOWTO (R_NDS32_DWARF2_OP1_RELA,       /* type */
1488          0,                     /* rightshift */
1489          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1490          8,                     /* bitsize */
1491          FALSE,                 /* pc_relative */
1492          0,                     /* bitpos */
1493          complain_overflow_dont,/* complain_on_overflow */
1494          nds32_elf_ignore_reloc,/* special_function */
1495          "R_NDS32_DWARF2_OP1_RELA",     /* name */
1496          FALSE,                 /* partial_inplace */
1497          0xff,                  /* src_mask */
1498          0xff,                  /* dst_mask */
1499          FALSE),                /* pcrel_offset */
1500   HOWTO (R_NDS32_DWARF2_OP2_RELA,       /* type */
1501          0,                     /* rightshift */
1502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1503          16,                    /* bitsize */
1504          FALSE,                 /* pc_relative */
1505          0,                     /* bitpos */
1506          complain_overflow_dont,/* complain_on_overflow */
1507          nds32_elf_ignore_reloc,/* special_function */
1508          "R_NDS32_DWARF2_OP2_RELA",     /* name */
1509          FALSE,                 /* partial_inplace */
1510          0xffff,                /* src_mask */
1511          0xffff,                /* dst_mask */
1512          FALSE),                /* pcrel_offset */
1513   HOWTO (R_NDS32_DWARF2_LEB_RELA,       /* type */
1514          0,                     /* rightshift */
1515          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1516          32,                    /* bitsize */
1517          FALSE,                 /* pc_relative */
1518          0,                     /* bitpos */
1519          complain_overflow_dont,/* complain_on_overflow */
1520          nds32_elf_ignore_reloc,/* special_function */
1521          "R_NDS32_DWARF2_LEB_RELA",     /* name */
1522          FALSE,                 /* partial_inplace */
1523          0xffffffff,            /* src_mask */
1524          0xffffffff,            /* dst_mask */
1525          FALSE),                /* pcrel_offset */
1526   HOWTO (R_NDS32_UPDATE_TA_RELA,/* type */
1527          0,                     /* rightshift */
1528          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1529          16,                    /* bitsize */
1530          FALSE,                 /* pc_relative */
1531          0,                     /* bitpos */
1532          complain_overflow_dont,/* complain_on_overflow */
1533          nds32_elf_ignore_reloc,/* special_function */
1534          "R_NDS32_UPDATE_TA_RELA",      /* name */
1535          FALSE,                 /* partial_inplace */
1536          0xffff,                /* src_mask */
1537          0xffff,                /* dst_mask */
1538          FALSE),                /* pcrel_offset */
1539   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1540      entry for the symbol.  */
1541   HOWTO (R_NDS32_9_PLTREL,      /* type */
1542          1,                     /* rightshift */
1543          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1544          8,                     /* bitsize */
1545          TRUE,                  /* pc_relative */
1546          0,                     /* bitpos */
1547          complain_overflow_signed,      /* complain_on_overflow */
1548          bfd_elf_generic_reloc, /* special_function */
1549          "R_NDS32_9_PLTREL",    /* name */
1550          FALSE,                 /* partial_inplace */
1551          0xff,                  /* src_mask */
1552          0xff,                  /* dst_mask */
1553          TRUE),                 /* pcrel_offset */
1554   /* Low 20 bits of PLT symbol offset relative to GOT (GP).  */
1555   HOWTO (R_NDS32_PLT_GOTREL_LO20,       /* type */
1556          0,                     /* rightshift */
1557          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1558          20,                    /* bitsize */
1559          FALSE,                 /* pc_relative */
1560          0,                     /* bitpos */
1561          complain_overflow_dont,/* complain_on_overflow */
1562          bfd_elf_generic_reloc, /* special_function */
1563          "R_NDS32_PLT_GOTREL_LO20",     /* name */
1564          FALSE,                 /* partial_inplace */
1565          0x000fffff,            /* src_mask */
1566          0x000fffff,            /* dst_mask */
1567          FALSE),                /* pcrel_offset */
1568   /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1569   HOWTO (R_NDS32_PLT_GOTREL_LO15,       /* type */
1570          0,                     /* rightshift */
1571          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          15,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_dont,/* complain_on_overflow */
1576          bfd_elf_generic_reloc, /* special_function */
1577          "R_NDS32_PLT_GOTREL_LO15",     /* name */
1578          FALSE,                 /* partial_inplace */
1579          0x00007fff,            /* src_mask */
1580          0x00007fff,            /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582   /* Low 19 bits of PLT symbol offset relative to GOT (GP).  */
1583   HOWTO (R_NDS32_PLT_GOTREL_LO19,       /* type */
1584          0,                     /* rightshift */
1585          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          19,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_dont,/* complain_on_overflow */
1590          bfd_elf_generic_reloc, /* special_function */
1591          "R_NDS32_PLT_GOTREL_LO19",     /* name */
1592          FALSE,                 /* partial_inplace */
1593          0x0007ffff,            /* src_mask */
1594          0x0007ffff,            /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596   HOWTO (R_NDS32_GOT_LO15,      /* type */
1597          0,                     /* rightshift */
1598          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1599          15,                    /* bitsize */
1600          FALSE,                 /* pc_relative */
1601          0,                     /* bitpos */
1602          complain_overflow_dont,/* complain_on_overflow */
1603          bfd_elf_generic_reloc, /* special_function */
1604          "R_NDS32_GOT_LO15",    /* name */
1605          FALSE,                 /* partial_inplace */
1606          0x00007fff,            /* src_mask */
1607          0x00007fff,            /* dst_mask */
1608          FALSE),                /* pcrel_offset */
1609   HOWTO (R_NDS32_GOT_LO19,      /* type */
1610          0,                     /* rightshift */
1611          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1612          19,                    /* bitsize */
1613          FALSE,                 /* pc_relative */
1614          0,                     /* bitpos */
1615          complain_overflow_dont,/* complain_on_overflow */
1616          bfd_elf_generic_reloc, /* special_function */
1617          "R_NDS32_GOT_LO19",    /* name */
1618          FALSE,                 /* partial_inplace */
1619          0x0007ffff,            /* src_mask */
1620          0x0007ffff,            /* dst_mask */
1621          FALSE),                /* pcrel_offset */
1622   HOWTO (R_NDS32_GOTOFF_LO15,   /* type */
1623          0,                     /* rightshift */
1624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1625          15,                    /* bitsize */
1626          FALSE,                 /* pc_relative */
1627          0,                     /* bitpos */
1628          complain_overflow_dont,/* complain_on_overflow */
1629          bfd_elf_generic_reloc, /* special_function */
1630          "R_NDS32_GOTOFF_LO15", /* name */
1631          FALSE,                 /* partial_inplace */
1632          0x00007fff,            /* src_mask */
1633          0x00007fff,            /* dst_mask */
1634          FALSE),                /* pcrel_offset */
1635   HOWTO (R_NDS32_GOTOFF_LO19,   /* type */
1636          0,                     /* rightshift */
1637          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          19,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont,/* complain_on_overflow */
1642          bfd_elf_generic_reloc, /* special_function */
1643          "R_NDS32_GOTOFF_LO19", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0x0007ffff,            /* src_mask */
1646          0x0007ffff,            /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648   /* GOT 15 bits offset.  */
1649   HOWTO (R_NDS32_GOT15S2_RELA,  /* type */
1650          2,                     /* rightshift */
1651          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1652          15,                    /* bitsize */
1653          FALSE,                 /* pc_relative */
1654          0,                     /* bitpos */
1655          complain_overflow_signed,      /* complain_on_overflow */
1656          bfd_elf_generic_reloc, /* special_function */
1657          "R_NDS32_GOT15S2_RELA",/* name */
1658          FALSE,                 /* partial_inplace */
1659          0x00007fff,            /* src_mask */
1660          0x00007fff,            /* dst_mask */
1661          FALSE),                /* pcrel_offset */
1662   /* GOT 17 bits offset.  */
1663   HOWTO (R_NDS32_GOT17S2_RELA,  /* type */
1664          2,                     /* rightshift */
1665          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1666          17,                    /* bitsize */
1667          FALSE,                 /* pc_relative */
1668          0,                     /* bitpos */
1669          complain_overflow_signed,      /* complain_on_overflow */
1670          bfd_elf_generic_reloc, /* special_function */
1671          "R_NDS32_GOT17S2_RELA",/* name */
1672          FALSE,                 /* partial_inplace */
1673          0x0001ffff,            /* src_mask */
1674          0x0001ffff,            /* dst_mask */
1675          FALSE),                /* pcrel_offset */
1676   /* A 5 bit address.  */
1677   HOWTO (R_NDS32_5_RELA,        /* type */
1678          0,                     /* rightshift */
1679          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1680          5,                     /* bitsize */
1681          FALSE,                 /* pc_relative */
1682          0,                     /* bitpos */
1683          complain_overflow_signed,      /* complain_on_overflow */
1684          bfd_elf_generic_reloc, /* special_function */
1685          "R_NDS32_5_RELA",      /* name */
1686          FALSE,                 /* partial_inplace */
1687          0x1f,                  /* src_mask */
1688          0x1f,                  /* dst_mask */
1689          FALSE),                /* pcrel_offset */
1690   HOWTO (R_NDS32_10_UPCREL_RELA,/* type */
1691          1,                     /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          9,                     /* bitsize */
1694          TRUE,                  /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_unsigned,    /* complain_on_overflow */
1697          bfd_elf_generic_reloc, /* special_function */
1698          "R_NDS32_10_UPCREL_RELA",      /* name */
1699          FALSE,                 /* partial_inplace */
1700          0x1ff,                 /* src_mask */
1701          0x1ff,                 /* dst_mask */
1702          TRUE),                 /* pcrel_offset */
1703   HOWTO (R_NDS32_SDA_FP7U2_RELA,/* type */
1704          2,                     /* rightshift */
1705          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1706          7,                     /* bitsize */
1707          FALSE,                 /* pc_relative */
1708          0,                     /* bitpos */
1709          complain_overflow_unsigned,    /* complain_on_overflow */
1710          bfd_elf_generic_reloc, /* special_function */
1711          "R_NDS32_SDA_FP7U2_RELA",      /* name */
1712          FALSE,                 /* partial_inplace */
1713          0x0000007f,            /* src_mask */
1714          0x0000007f,            /* dst_mask */
1715          FALSE),                /* pcrel_offset */
1716   HOWTO (R_NDS32_WORD_9_PCREL_RELA,     /* type */
1717          1,                     /* rightshift */
1718          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1719          8,                     /* bitsize */
1720          TRUE,                  /* pc_relative */
1721          0,                     /* bitpos */
1722          complain_overflow_signed,      /* complain_on_overflow */
1723          bfd_elf_generic_reloc, /* special_function */
1724          "R_NDS32_WORD_9_PCREL_RELA",   /* name */
1725          FALSE,                 /* partial_inplace */
1726          0xff,                  /* src_mask */
1727          0xff,                  /* dst_mask */
1728          TRUE),                 /* pcrel_offset */
1729   HOWTO (R_NDS32_25_ABS_RELA,   /* type */
1730          1,                     /* rightshift */
1731          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1732          24,                    /* bitsize */
1733          FALSE,                 /* pc_relative */
1734          0,                     /* bitpos */
1735          complain_overflow_dont,/* complain_on_overflow */
1736          bfd_elf_generic_reloc, /* special_function */
1737          "R_NDS32_25_ABS_RELA", /* name */
1738          FALSE,                 /* partial_inplace */
1739          0xffffff,              /* src_mask */
1740          0xffffff,              /* dst_mask */
1741          FALSE),                /* pcrel_offset */
1742
1743   /* A relative 17 bit relocation for ifc, right shifted by 1.  */
1744   HOWTO (R_NDS32_17IFC_PCREL_RELA,      /* type */
1745          1,                     /* rightshift */
1746          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1747          16,                    /* bitsize */
1748          TRUE,                  /* pc_relative */
1749          0,                     /* bitpos */
1750          complain_overflow_signed,      /* complain_on_overflow */
1751          bfd_elf_generic_reloc, /* special_function */
1752          "R_NDS32_17IFC_PCREL_RELA",    /* name */
1753          FALSE,                 /* partial_inplace */
1754          0xffff,                /* src_mask */
1755          0xffff,                /* dst_mask */
1756          TRUE),                 /* pcrel_offset */
1757
1758   /* A relative unsigned 10 bit relocation for ifc, right shifted by 1.  */
1759   HOWTO (R_NDS32_10IFCU_PCREL_RELA,     /* type */
1760          1,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          9,                     /* bitsize */
1763          TRUE,                  /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_unsigned,    /* complain_on_overflow */
1766          bfd_elf_generic_reloc, /* special_function */
1767          "R_NDS32_10IFCU_PCREL_RELA",   /* name */
1768          FALSE,                 /* partial_inplace */
1769          0x1ff,                 /* src_mask */
1770          0x1ff,                 /* dst_mask */
1771          TRUE),                 /* pcrel_offset */
1772
1773   /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol.  */
1774   HOWTO (R_NDS32_TLS_LE_HI20,   /* type */
1775          12,                    /* rightshift */
1776          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          20,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont,        /* complain_on_overflow */
1781          bfd_elf_generic_reloc, /* special_function */
1782          "R_NDS32_TLS_LE_HI20", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0x000fffff,            /* src_mask */
1785          0x000fffff,            /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787   HOWTO (R_NDS32_TLS_LE_LO12,   /* type */
1788          0,                     /* rightshift */
1789          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1790          12,                    /* bitsize */
1791          FALSE,                 /* pc_relative */
1792          0,                     /* bitpos */
1793          complain_overflow_dont,        /* complain_on_overflow */
1794          bfd_elf_generic_reloc, /* special_function */
1795          "R_NDS32_TLS_LE_LO12", /* name */
1796          FALSE,                 /* partial_inplace */
1797          0x00000fff,            /* src_mask */
1798          0x00000fff,            /* dst_mask */
1799          FALSE),                /* pcrel_offset */
1800
1801   /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol.  */
1802   HOWTO (R_NDS32_TLS_IE_HI20,   /* type */
1803          12,                    /* rightshift */
1804          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1805          20,                    /* bitsize */
1806          FALSE,                 /* pc_relative */
1807          0,                     /* bitpos */
1808          complain_overflow_dont,        /* complain_on_overflow */
1809          bfd_elf_generic_reloc, /* special_function */
1810          "R_NDS32_TLS_IE_HI20", /* name */
1811          FALSE,                 /* partial_inplace */
1812          0x000fffff,            /* src_mask */
1813          0x000fffff,            /* dst_mask */
1814          FALSE),                /* pcrel_offset */
1815   HOWTO (R_NDS32_TLS_IE_LO12S2, /* type */
1816          2,                     /* rightshift */
1817          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1818          10,                    /* bitsize */
1819          FALSE,                 /* pc_relative */
1820          0,                     /* bitpos */
1821          complain_overflow_dont,        /* complain_on_overflow */
1822          bfd_elf_generic_reloc, /* special_function */
1823          "R_NDS32_TLS_IE_LO12S2",       /* name */
1824          FALSE,                 /* partial_inplace */
1825          0x000003ff,            /* src_mask */
1826          0x000003ff,            /* dst_mask */
1827          FALSE),                /* pcrel_offset */
1828   /* Mark a TLS IE entry in GOT.  */
1829   HOWTO (R_NDS32_TLS_TPOFF,     /* type */
1830          0,                     /* rightshift */
1831          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          32,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_bitfield,    /* complain_on_overflow */
1836          bfd_elf_generic_reloc, /* special_function */
1837          "R_NDS32_TLS_TPOFF",   /* name */
1838          FALSE,                 /* partial_inplace */
1839          0xffffffff,            /* src_mask */
1840          0xffffffff,            /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842   /* A 20 bit address.  */
1843   HOWTO (R_NDS32_TLS_LE_20,     /* type */
1844          0,                     /* rightshift */
1845          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          20,                    /* bitsize */
1847          FALSE,         /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed,      /* complain_on_overflow */
1850          bfd_elf_generic_reloc, /* special_function */
1851          "R_NDS32_TLS_LE_20",   /* name */
1852          FALSE,         /* partial_inplace */
1853          0xfffff,               /* src_mask */
1854          0xfffff,               /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856   HOWTO (R_NDS32_TLS_LE_15S0,   /* type */
1857          0,                     /* rightshift */
1858          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1859          15,                    /* bitsize */
1860          FALSE,         /* pc_relative */
1861          0,                     /* bitpos */
1862          complain_overflow_signed,      /* complain_on_overflow */
1863          bfd_elf_generic_reloc, /* special_function */
1864          "R_NDS32_TLS_LE_15S0", /* name */
1865          FALSE,         /* partial_inplace */
1866          0x7fff,                /* src_mask */
1867          0x7fff,                /* dst_mask */
1868          FALSE),                /* pcrel_offset */
1869   HOWTO (R_NDS32_TLS_LE_15S1,   /* type */
1870          1,                     /* rightshift */
1871          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1872          15,                    /* bitsize */
1873          FALSE,         /* pc_relative */
1874          0,                     /* bitpos */
1875          complain_overflow_signed,      /* complain_on_overflow */
1876          bfd_elf_generic_reloc, /* special_function */
1877          "R_NDS32_TLS_LE_15S1", /* name */
1878          FALSE,         /* partial_inplace */
1879          0x7fff,                /* src_mask */
1880          0x7fff,                /* dst_mask */
1881          FALSE),                /* pcrel_offset */
1882   HOWTO (R_NDS32_TLS_LE_15S2,   /* type */
1883          2,                     /* rightshift */
1884          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1885          15,                    /* bitsize */
1886          FALSE,         /* pc_relative */
1887          0,                     /* bitpos */
1888          complain_overflow_signed,      /* complain_on_overflow */
1889          bfd_elf_generic_reloc, /* special_function */
1890          "R_NDS32_TLS_LE_15S2", /* name */
1891          FALSE,         /* partial_inplace */
1892          0x7fff,                /* src_mask */
1893          0x7fff,                /* dst_mask */
1894          FALSE),                /* pcrel_offset */
1895
1896   /* Relax hint for unconditional call sequence  */
1897   HOWTO (R_NDS32_LONGCALL4,     /* type */
1898          0,                     /* rightshift */
1899          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1900          32,                    /* bitsize */
1901          FALSE,                 /* pc_relative */
1902          0,                     /* bitpos */
1903          complain_overflow_dont,        /* complain_on_overflow */
1904          nds32_elf_ignore_reloc,        /* special_function */
1905          "R_NDS32_LONGCALL4",   /* name */
1906          FALSE,                 /* partial_inplace */
1907          0xffffffff,            /* src_mask */
1908          0xffffffff,            /* dst_mask */
1909          FALSE),                /* pcrel_offset */
1910
1911   /* Relax hint for conditional call sequence.  */
1912   HOWTO (R_NDS32_LONGCALL5,     /* type */
1913          0,                     /* rightshift */
1914          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1915          32,                    /* bitsize */
1916          FALSE,                 /* pc_relative */
1917          0,                     /* bitpos */
1918          complain_overflow_dont,        /* complain_on_overflow */
1919          nds32_elf_ignore_reloc,        /* special_function */
1920          "R_NDS32_LONGCALL5",   /* name */
1921          FALSE,                 /* partial_inplace */
1922          0xffffffff,            /* src_mask */
1923          0xffffffff,            /* dst_mask */
1924          FALSE),                /* pcrel_offset */
1925
1926   /* Relax hint for conditional call sequence.  */
1927   HOWTO (R_NDS32_LONGCALL6,     /* type */
1928          0,                     /* rightshift */
1929          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1930          32,                    /* bitsize */
1931          FALSE,                 /* pc_relative */
1932          0,                     /* bitpos */
1933          complain_overflow_dont,        /* complain_on_overflow */
1934          nds32_elf_ignore_reloc,        /* special_function */
1935          "R_NDS32_LONGCALL6",   /* name */
1936          FALSE,                 /* partial_inplace */
1937          0xffffffff,            /* src_mask */
1938          0xffffffff,            /* dst_mask */
1939          FALSE),                /* pcrel_offset */
1940
1941   /* Relax hint for unconditional branch sequence.  */
1942   HOWTO (R_NDS32_LONGJUMP4,     /* 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_LONGJUMP4",   /* name */
1951          FALSE,                 /* partial_inplace */
1952          0xffffffff,            /* src_mask */
1953          0xffffffff,            /* dst_mask */
1954          FALSE),                /* pcrel_offset */
1955
1956   /* Relax hint for conditional branch sequence.  */
1957   HOWTO (R_NDS32_LONGJUMP5,     /* type */
1958          0,                     /* rightshift */
1959          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1960          32,                    /* bitsize */
1961          FALSE,                 /* pc_relative */
1962          0,                     /* bitpos */
1963          complain_overflow_dont,        /* complain_on_overflow */
1964          nds32_elf_ignore_reloc,        /* special_function */
1965          "R_NDS32_LONGJUMP5",   /* name */
1966          FALSE,                 /* partial_inplace */
1967          0xffffffff,            /* src_mask */
1968          0xffffffff,            /* dst_mask */
1969          FALSE),                /* pcrel_offset */
1970
1971   /* Relax hint for conditional branch sequence.  */
1972   HOWTO (R_NDS32_LONGJUMP6,     /* type */
1973          0,                     /* rightshift */
1974          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1975          32,                    /* bitsize */
1976          FALSE,                 /* pc_relative */
1977          0,                     /* bitpos */
1978          complain_overflow_dont,        /* complain_on_overflow */
1979          nds32_elf_ignore_reloc,        /* special_function */
1980          "R_NDS32_LONGJUMP6",   /* name */
1981          FALSE,                 /* partial_inplace */
1982          0xffffffff,            /* src_mask */
1983          0xffffffff,            /* dst_mask */
1984          FALSE),                /* pcrel_offset */
1985
1986   /* Relax hint for conditional branch sequence.  */
1987   HOWTO (R_NDS32_LONGJUMP7,     /* type */
1988          0,                     /* rightshift */
1989          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1990          32,                    /* bitsize */
1991          FALSE,                 /* pc_relative */
1992          0,                     /* bitpos */
1993          complain_overflow_dont,        /* complain_on_overflow */
1994          nds32_elf_ignore_reloc,        /* special_function */
1995          "R_NDS32_LONGJUMP7",   /* name */
1996          FALSE,                 /* partial_inplace */
1997          0xffffffff,            /* src_mask */
1998          0xffffffff,            /* dst_mask */
1999          FALSE),                /* pcrel_offset */
2000 };
2001
2002 /* Relocations used for relaxation.  */
2003 static reloc_howto_type nds32_elf_relax_howto_table[] =
2004 {
2005   HOWTO (R_NDS32_RELAX_ENTRY,   /* type */
2006          0,                     /* rightshift */
2007          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2008          32,                    /* bitsize */
2009          FALSE,                 /* pc_relative */
2010          0,                     /* bitpos */
2011          complain_overflow_dont,/* complain_on_overflow */
2012          nds32_elf_ignore_reloc,/* special_function */
2013          "R_NDS32_RELAX_ENTRY", /* name */
2014          FALSE,                 /* partial_inplace */
2015          0xffffffff,            /* src_mask */
2016          0xffffffff,            /* dst_mask */
2017          FALSE),                /* pcrel_offset */
2018   HOWTO (R_NDS32_GOT_SUFF,      /* type */
2019          0,                     /* rightshift */
2020          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2021          32,                    /* bitsize */
2022          FALSE,                 /* pc_relative */
2023          0,                     /* bitpos */
2024          complain_overflow_dont,/* complain_on_overflow */
2025          nds32_elf_ignore_reloc,/* special_function */
2026          "R_NDS32_GOT_SUFF",    /* name */
2027          FALSE,                 /* partial_inplace */
2028          0xffffffff,            /* src_mask */
2029          0xffffffff,            /* dst_mask */
2030          FALSE),                /* pcrel_offset */
2031   HOWTO (R_NDS32_GOTOFF_SUFF,   /* type */
2032          0,                     /* rightshift */
2033          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2034          32,                    /* bitsize */
2035          FALSE,                 /* pc_relative */
2036          0,                     /* bitpos */
2037          complain_overflow_bitfield,    /* complain_on_overflow */
2038          nds32_elf_ignore_reloc,/* special_function */
2039          "R_NDS32_GOTOFF_SUFF", /* name */
2040          FALSE,                 /* partial_inplace */
2041          0xffffffff,            /* src_mask */
2042          0xffffffff,            /* dst_mask */
2043          FALSE),                /* pcrel_offset */
2044   HOWTO (R_NDS32_PLT_GOT_SUFF,  /* type */
2045          0,                     /* rightshift */
2046          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2047          32,                    /* bitsize */
2048          FALSE,                 /* pc_relative */
2049          0,                     /* bitpos */
2050          complain_overflow_dont,/* complain_on_overflow */
2051          nds32_elf_ignore_reloc,/* special_function */
2052          "R_NDS32_PLT_GOT_SUFF",/* name */
2053          FALSE,                 /* partial_inplace */
2054          0xffffffff,            /* src_mask */
2055          0xffffffff,            /* dst_mask */
2056          FALSE),                /* pcrel_offset */
2057   HOWTO (R_NDS32_MULCALL_SUFF,  /* type */
2058          0,                     /* rightshift */
2059          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2060          32,                    /* bitsize */
2061          FALSE,                 /* pc_relative */
2062          0,                     /* bitpos */
2063          complain_overflow_dont,/* complain_on_overflow */
2064          nds32_elf_ignore_reloc,/* special_function */
2065          "R_NDS32_MULCALL_SUFF",/* name */
2066          FALSE,                 /* partial_inplace */
2067          0xffffffff,            /* src_mask */
2068          0xffffffff,            /* dst_mask */
2069          FALSE),                /* pcrel_offset */
2070   HOWTO (R_NDS32_PTR,           /* type */
2071          0,                     /* rightshift */
2072          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2073          32,                    /* bitsize */
2074          FALSE,                 /* pc_relative */
2075          0,                     /* bitpos */
2076          complain_overflow_dont,/* complain_on_overflow */
2077          nds32_elf_ignore_reloc,/* special_function */
2078          "R_NDS32_PTR",         /* name */
2079          FALSE,                 /* partial_inplace */
2080          0xffffffff,            /* src_mask */
2081          0xffffffff,            /* dst_mask */
2082          FALSE),                /* pcrel_offset */
2083   HOWTO (R_NDS32_PTR_COUNT,     /* type */
2084          0,                     /* rightshift */
2085          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2086          32,                    /* bitsize */
2087          FALSE,                 /* pc_relative */
2088          0,                     /* bitpos */
2089          complain_overflow_dont,/* complain_on_overflow */
2090          nds32_elf_ignore_reloc,/* special_function */
2091          "R_NDS32_PTR_COUNT",   /* name */
2092          FALSE,                 /* partial_inplace */
2093          0xffffffff,            /* src_mask */
2094          0xffffffff,            /* dst_mask */
2095          FALSE),                /* pcrel_offset */
2096   HOWTO (R_NDS32_PTR_RESOLVED,  /* type */
2097          0,                     /* rightshift */
2098          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2099          32,                    /* bitsize */
2100          FALSE,                 /* pc_relative */
2101          0,                     /* bitpos */
2102          complain_overflow_dont,/* complain_on_overflow */
2103          nds32_elf_ignore_reloc,/* special_function */
2104          "R_NDS32_PTR_RESOLVED",/* name */
2105          FALSE,                 /* partial_inplace */
2106          0xffffffff,            /* src_mask */
2107          0xffffffff,            /* dst_mask */
2108          FALSE),                /* pcrel_offset */
2109   HOWTO (R_NDS32_PLTBLOCK,      /* type */
2110          0,                     /* rightshift */
2111          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2112          32,                    /* bitsize */
2113          FALSE,                 /* pc_relative */
2114          0,                     /* bitpos */
2115          complain_overflow_dont,/* complain_on_overflow */
2116          nds32_elf_ignore_reloc,/* special_function */
2117          "R_NDS32_PLTBLOCK",    /* name */
2118          FALSE,                 /* partial_inplace */
2119          0xffffffff,            /* src_mask */
2120          0xffffffff,            /* dst_mask */
2121          FALSE),                /* pcrel_offset */
2122   HOWTO (R_NDS32_RELAX_REGION_BEGIN,    /* type */
2123          0,                     /* rightshift */
2124          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2125          32,                    /* bitsize */
2126          FALSE,                 /* pc_relative */
2127          0,                     /* bitpos */
2128          complain_overflow_dont,/* complain_on_overflow */
2129          nds32_elf_ignore_reloc,/* special_function */
2130          "R_NDS32_RELAX_REGION_BEGIN",  /* name */
2131          FALSE,                 /* partial_inplace */
2132          0xffffffff,            /* src_mask */
2133          0xffffffff,            /* dst_mask */
2134          FALSE),                /* pcrel_offset */
2135   HOWTO (R_NDS32_RELAX_REGION_END,      /* type */
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont,/* complain_on_overflow */
2142          nds32_elf_ignore_reloc,/* special_function */
2143          "R_NDS32_RELAX_REGION_END",    /* name */
2144          FALSE,                 /* partial_inplace */
2145          0xffffffff,            /* src_mask */
2146          0xffffffff,            /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148   HOWTO (R_NDS32_MINUEND,       /* type */
2149          0,                     /* rightshift */
2150          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2151          32,                    /* bitsize */
2152          FALSE,                 /* pc_relative */
2153          0,                     /* bitpos */
2154          complain_overflow_dont,/* complain_on_overflow */
2155          nds32_elf_ignore_reloc,/* special_function */
2156          "R_NDS32_MINUEND",     /* name */
2157          FALSE,                 /* partial_inplace */
2158          0xffffffff,            /* src_mask */
2159          0xffffffff,            /* dst_mask */
2160          FALSE),                /* pcrel_offset */
2161   HOWTO (R_NDS32_SUBTRAHEND,    /* type */
2162          0,                     /* rightshift */
2163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2164          32,                    /* bitsize */
2165          FALSE,                 /* pc_relative */
2166          0,                     /* bitpos */
2167          complain_overflow_dont,/* complain_on_overflow */
2168          nds32_elf_ignore_reloc,/* special_function */
2169          "R_NDS32_SUBTRAHEND",  /* name */
2170          FALSE,                 /* partial_inplace */
2171          0xffffffff,            /* src_mask */
2172          0xffffffff,            /* dst_mask */
2173          FALSE),                /* pcrel_offset */
2174   HOWTO (R_NDS32_DIFF8,         /* type */
2175          0,                     /* rightshift */
2176          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2177          8,                     /* bitsize */
2178          FALSE,                 /* pc_relative */
2179          0,                     /* bitpos */
2180          complain_overflow_dont,/* complain_on_overflow */
2181          nds32_elf_ignore_reloc,/* special_function */
2182          "R_NDS32_DIFF8",       /* name */
2183          FALSE,                 /* partial_inplace */
2184          0x000000ff,            /* src_mask */
2185          0x000000ff,            /* dst_mask */
2186          FALSE),                /* pcrel_offset */
2187   HOWTO (R_NDS32_DIFF16,        /* type */
2188          0,                     /* rightshift */
2189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2190          16,                    /* bitsize */
2191          FALSE,                 /* pc_relative */
2192          0,                     /* bitpos */
2193          complain_overflow_dont,/* complain_on_overflow */
2194          nds32_elf_ignore_reloc,/* special_function */
2195          "R_NDS32_DIFF16",      /* name */
2196          FALSE,                 /* partial_inplace */
2197          0x0000ffff,            /* src_mask */
2198          0x0000ffff,            /* dst_mask */
2199          FALSE),                /* pcrel_offset */
2200   HOWTO (R_NDS32_DIFF32,        /* type */
2201          0,                     /* rightshift */
2202          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          32,                    /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont,/* complain_on_overflow */
2207          nds32_elf_ignore_reloc,/* special_function */
2208          "R_NDS32_DIFF32",      /* name */
2209          FALSE,                 /* partial_inplace */
2210          0xffffffff,            /* src_mask */
2211          0xffffffff,            /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213   HOWTO (R_NDS32_DIFF_ULEB128,  /* type */
2214          0,                     /* rightshift */
2215          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2216          0,                     /* bitsize */
2217          FALSE,                 /* pc_relative */
2218          0,                     /* bitpos */
2219          complain_overflow_dont,/* complain_on_overflow */
2220          nds32_elf_ignore_reloc,/* special_function */
2221          "R_NDS32_DIFF_ULEB128",/* name */
2222          FALSE,                 /* partial_inplace */
2223          0xffffffff,            /* src_mask */
2224          0xffffffff,            /* dst_mask */
2225          FALSE),                /* pcrel_offset */
2226   HOWTO (R_NDS32_DATA,          /* type */
2227          0,                     /* rightshift */
2228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2229          32,                    /* bitsize */
2230          FALSE,                 /* pc_relative */
2231          0,                     /* bitpos */
2232          complain_overflow_dont,/* complain_on_overflow */
2233          nds32_elf_ignore_reloc,/* special_function */
2234          "R_NDS32_DATA",        /* name */
2235          FALSE,                 /* partial_inplace */
2236          0xffffffff,            /* src_mask */
2237          0xffffffff,            /* dst_mask */
2238          FALSE),                /* pcrel_offset */
2239   HOWTO (R_NDS32_TRAN,          /* type */
2240          0,                     /* rightshift */
2241          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2242          32,                    /* bitsize */
2243          FALSE,                 /* pc_relative */
2244          0,                     /* bitpos */
2245          complain_overflow_dont,/* complain_on_overflow */
2246          nds32_elf_ignore_reloc,/* special_function */
2247          "R_NDS32_TRAN",        /* name */
2248          FALSE,                 /* partial_inplace */
2249          0xffffffff,            /* src_mask */
2250          0xffffffff,            /* dst_mask */
2251          FALSE),                /* pcrel_offset */
2252   HOWTO (R_NDS32_TLS_LE_ADD,    /* type */
2253          0,                     /* rightshift */
2254          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2255          32,                    /* bitsize */
2256          FALSE,                 /* pc_relative */
2257          0,                     /* bitpos */
2258          complain_overflow_dont,        /* complain_on_overflow */
2259          nds32_elf_ignore_reloc,        /* special_function */
2260          "R_NDS32_TLS_LE_ADD",  /* name */
2261          FALSE,                 /* partial_inplace */
2262          0xffffffff,            /* src_mask */
2263          0xffffffff,            /* dst_mask */
2264          FALSE),                /* pcrel_offset */
2265   HOWTO (R_NDS32_TLS_LE_LS,     /* type */
2266          0,                     /* rightshift */
2267          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2268          32,                    /* bitsize */
2269          FALSE,                 /* pc_relative */
2270          0,                     /* bitpos */
2271          complain_overflow_dont,        /* complain_on_overflow */
2272          nds32_elf_ignore_reloc,        /* special_function */
2273          "R_NDS32_TLS_LE_LS",   /* name */
2274          FALSE,                 /* partial_inplace */
2275          0xffffffff,            /* src_mask */
2276          0xffffffff,            /* dst_mask */
2277          FALSE),                /* pcrel_offset */
2278   HOWTO (R_NDS32_EMPTY,         /* type */
2279          0,                     /* rightshift */
2280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2281          32,                    /* bitsize */
2282          FALSE,                 /* pc_relative */
2283          0,                     /* bitpos */
2284          complain_overflow_dont,        /* complain_on_overflow */
2285          nds32_elf_ignore_reloc,        /* special_function */
2286          "R_NDS32_EMPTY",               /* name */
2287          FALSE,                 /* partial_inplace */
2288          0xffffffff,            /* src_mask */
2289          0xffffffff,            /* dst_mask */
2290          FALSE),                /* pcrel_offset */
2291 };
2292
2293 \f
2294 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2295    This prototype is the same as qsort ().  */
2296
2297 void
2298 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2299                       int (*compar) (const void *lhs, const void *rhs))
2300 {
2301   char *ptr = (char *) base;
2302   int i, j;
2303   char *tmp = alloca (size);
2304
2305   /* If i is less than j, i is inserted before j.
2306
2307      |---- j ----- i --------------|
2308       \          / \              /
2309          sorted         unsorted
2310    */
2311
2312   for (i = 1; i < (int) nmemb; i++)
2313     {
2314       for (j = (i - 1); j >= 0; j--)
2315         if (compar (ptr + i * size, ptr + j * size) >= 0)
2316           break;
2317
2318       j++;
2319
2320       if (i == j)
2321         continue; /* i is in order.  */
2322
2323       memcpy (tmp, ptr + i * size, size);
2324       memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2325       memcpy (ptr + j * size, tmp, size);
2326     }
2327 }
2328
2329 /* Sort relocation by r_offset.
2330
2331    We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2332    algorithm.  Relocations at the same r_offset must keep their order.
2333    For example, RELAX_ENTRY must be the very first relocation entry.
2334
2335    Currently, this function implements insertion-sort.
2336
2337    FIXME: If we already sort them in assembler, why bother sort them
2338           here again?  */
2339
2340 static int
2341 compar_reloc (const void *lhs, const void *rhs)
2342 {
2343   const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2344   const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2345
2346   if (l->r_offset > r->r_offset)
2347     return 1;
2348   else if (l->r_offset == r->r_offset)
2349     return 0;
2350   else
2351     return -1;
2352 }
2353
2354 /* Functions listed below are only used for old relocs.
2355    * nds32_elf_9_pcrel_reloc
2356    * nds32_elf_do_9_pcrel_reloc
2357    * nds32_elf_hi20_reloc
2358    * nds32_elf_relocate_hi20
2359    * nds32_elf_lo12_reloc
2360    * nds32_elf_sda15_reloc
2361    * nds32_elf_generic_reloc
2362    */
2363
2364 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc.  */
2365
2366 static bfd_reloc_status_type
2367 nds32_elf_9_pcrel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2368                          void *data, asection *input_section, bfd *output_bfd,
2369                          char **error_message ATTRIBUTE_UNUSED)
2370 {
2371   /* This part is from bfd_elf_generic_reloc.  */
2372   if (output_bfd != (bfd *) NULL
2373       && (symbol->flags & BSF_SECTION_SYM) == 0
2374       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2375     {
2376       reloc_entry->address += input_section->output_offset;
2377       return bfd_reloc_ok;
2378     }
2379
2380   if (output_bfd != NULL)
2381     {
2382       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2383       return bfd_reloc_continue;
2384     }
2385
2386   return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2387                                      input_section,
2388                                      data, reloc_entry->address,
2389                                      symbol->section,
2390                                      (symbol->value
2391                                       + symbol->section->output_section->vma
2392                                       + symbol->section->output_offset),
2393                                      reloc_entry->addend);
2394 }
2395
2396 /* Utility to actually perform an R_NDS32_9_PCREL reloc.  */
2397 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2398
2399 static bfd_reloc_status_type
2400 nds32_elf_do_9_pcrel_reloc (bfd *abfd, reloc_howto_type *howto,
2401                             asection *input_section, bfd_byte *data,
2402                             bfd_vma offset,
2403                             asection *symbol_section ATTRIBUTE_UNUSED,
2404                             bfd_vma symbol_value, bfd_vma addend)
2405 {
2406   bfd_signed_vma relocation;
2407   unsigned short x;
2408   bfd_reloc_status_type status;
2409
2410   /* Sanity check the address (offset in section).  */
2411   if (offset > bfd_get_section_limit (abfd, input_section))
2412     return bfd_reloc_outofrange;
2413
2414   relocation = symbol_value + addend;
2415   /* Make it pc relative.  */
2416   relocation -= (input_section->output_section->vma
2417                  + input_section->output_offset);
2418   /* These jumps mask off the lower two bits of the current address
2419      before doing pcrel calculations.  */
2420   relocation -= (offset & -(bfd_vma) 2);
2421
2422   if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2423     status = bfd_reloc_overflow;
2424   else
2425     status = bfd_reloc_ok;
2426
2427   x = bfd_getb16 (data + offset);
2428
2429   relocation >>= howto->rightshift;
2430   relocation <<= howto->bitpos;
2431   x = (x & ~howto->dst_mask)
2432       | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2433
2434   bfd_putb16 ((bfd_vma) x, data + offset);
2435
2436   return status;
2437 }
2438
2439 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2440    HI20_SLO is for the add3 and load/store with displacement instructions.
2441    HI20 is for the or3 instruction.
2442    For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2443    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2444    we must add one to the high 16 bytes (which will get subtracted off when
2445    the low 16 bits are added).
2446    These relocs have to be done in combination with an R_NDS32_LO12 reloc
2447    because there is a carry from the LO12 to the HI20.  Here we just save
2448    the information we need; we do the actual relocation when we see the LO12.
2449    This code is copied from the elf32-mips.c.  We also support an arbitrary
2450    number of HI20 relocs to be associated with a single LO12 reloc.  The
2451    assembler sorts the relocs to ensure each HI20 immediately precedes its
2452    LO12.  However if there are multiple copies, the assembler may not find
2453    the real LO12 so it picks the first one it finds.  */
2454
2455 struct nds32_hi20
2456 {
2457   struct nds32_hi20 *next;
2458   bfd_byte *addr;
2459   bfd_vma addend;
2460 };
2461
2462 static struct nds32_hi20 *nds32_hi20_list;
2463
2464 static bfd_reloc_status_type
2465 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2466                       asymbol *symbol, void *data, asection *input_section,
2467                       bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2468 {
2469   bfd_reloc_status_type ret;
2470   bfd_vma relocation;
2471   struct nds32_hi20 *n;
2472
2473   /* This part is from bfd_elf_generic_reloc.
2474      If we're relocating, and this an external symbol, we don't want
2475      to change anything.  */
2476   if (output_bfd != (bfd *) NULL
2477       && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2478     {
2479       reloc_entry->address += input_section->output_offset;
2480       return bfd_reloc_ok;
2481     }
2482
2483   /* Sanity check the address (offset in section).  */
2484   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2485     return bfd_reloc_outofrange;
2486
2487   ret = bfd_reloc_ok;
2488   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2489     ret = bfd_reloc_undefined;
2490
2491   if (bfd_is_com_section (symbol->section))
2492     relocation = 0;
2493   else
2494     relocation = symbol->value;
2495
2496   relocation += symbol->section->output_section->vma;
2497   relocation += symbol->section->output_offset;
2498   relocation += reloc_entry->addend;
2499
2500   /* Save the information, and let LO12 do the actual relocation.  */
2501   n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2502   if (n == NULL)
2503     return bfd_reloc_outofrange;
2504
2505   n->addr = (bfd_byte *) data + reloc_entry->address;
2506   n->addend = relocation;
2507   n->next = nds32_hi20_list;
2508   nds32_hi20_list = n;
2509
2510   if (output_bfd != (bfd *) NULL)
2511     reloc_entry->address += input_section->output_offset;
2512
2513   return ret;
2514 }
2515
2516 /* Handle an NDS32 ELF HI20 reloc.  */
2517
2518 static void
2519 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2520                          int type ATTRIBUTE_UNUSED, Elf_Internal_Rela *relhi,
2521                          Elf_Internal_Rela *rello, bfd_byte *contents,
2522                          bfd_vma addend)
2523 {
2524   unsigned long insn;
2525   bfd_vma addlo;
2526
2527   insn = bfd_getb32 (contents + relhi->r_offset);
2528
2529   addlo = bfd_getb32 (contents + rello->r_offset);
2530   addlo &= 0xfff;
2531
2532   addend += ((insn & 0xfffff) << 20) + addlo;
2533
2534   insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2535   bfd_putb32 (insn, contents + relhi->r_offset);
2536 }
2537
2538 /* Do an R_NDS32_LO12 relocation.  This is a straightforward 12 bit
2539    inplace relocation; this function exists in order to do the
2540    R_NDS32_HI20_[SU]LO relocation described above.  */
2541
2542 static bfd_reloc_status_type
2543 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2544                       void *data, asection *input_section, bfd *output_bfd,
2545                       char **error_message)
2546 {
2547   /* This part is from bfd_elf_generic_reloc.
2548      If we're relocating, and this an external symbol, we don't want
2549      to change anything.  */
2550   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2551       && reloc_entry->addend == 0)
2552     {
2553       reloc_entry->address += input_section->output_offset;
2554       return bfd_reloc_ok;
2555     }
2556
2557   if (nds32_hi20_list != NULL)
2558     {
2559       struct nds32_hi20 *l;
2560
2561       l = nds32_hi20_list;
2562       while (l != NULL)
2563         {
2564           unsigned long insn;
2565           unsigned long val;
2566           unsigned long vallo;
2567           struct nds32_hi20 *next;
2568
2569           /* Do the HI20 relocation.  Note that we actually don't need
2570              to know anything about the LO12 itself, except where to
2571              find the low 12 bits of the addend needed by the LO12.  */
2572           insn = bfd_getb32 (l->addr);
2573           vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2574           vallo &= 0xfff;
2575           switch (reloc_entry->howto->type)
2576             {
2577             case R_NDS32_LO12S3:
2578               vallo <<= 3;
2579               break;
2580
2581             case R_NDS32_LO12S2:
2582               vallo <<= 2;
2583               break;
2584
2585             case R_NDS32_LO12S1:
2586               vallo <<= 1;
2587               break;
2588
2589             case R_NDS32_LO12S0:
2590               vallo <<= 0;
2591               break;
2592             }
2593
2594           val = ((insn & 0xfffff) << 12) + vallo;
2595           val += l->addend;
2596
2597           insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2598           bfd_putb32 ((bfd_vma) insn, l->addr);
2599
2600           next = l->next;
2601           free (l);
2602           l = next;
2603         }
2604
2605       nds32_hi20_list = NULL;
2606     }
2607
2608   /* Now do the LO12 reloc in the usual way.
2609      ??? It would be nice to call bfd_elf_generic_reloc here,
2610      but we have partial_inplace set.  bfd_elf_generic_reloc will
2611      pass the handling back to bfd_install_relocation which will install
2612      a section relative addend which is wrong.  */
2613   return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2614                                   input_section, output_bfd, error_message);
2615 }
2616
2617 /* Do generic partial_inplace relocation.
2618    This is a local replacement for bfd_elf_generic_reloc.  */
2619
2620 static bfd_reloc_status_type
2621 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2622                          asymbol *symbol, void *data, asection *input_section,
2623                          bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2624 {
2625   bfd_reloc_status_type ret;
2626   bfd_vma relocation;
2627   bfd_byte *inplace_address;
2628
2629   /* This part is from bfd_elf_generic_reloc.
2630      If we're relocating, and this an external symbol, we don't want
2631      to change anything.  */
2632   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2633       && reloc_entry->addend == 0)
2634     {
2635       reloc_entry->address += input_section->output_offset;
2636       return bfd_reloc_ok;
2637     }
2638
2639   /* Now do the reloc in the usual way.
2640      ??? It would be nice to call bfd_elf_generic_reloc here,
2641      but we have partial_inplace set.  bfd_elf_generic_reloc will
2642      pass the handling back to bfd_install_relocation which will install
2643      a section relative addend which is wrong.  */
2644
2645   /* Sanity check the address (offset in section).  */
2646   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2647     return bfd_reloc_outofrange;
2648
2649   ret = bfd_reloc_ok;
2650   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2651     ret = bfd_reloc_undefined;
2652
2653   if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2654     relocation = 0;
2655   else
2656     relocation = symbol->value;
2657
2658   /* Only do this for a final link.  */
2659   if (output_bfd == (bfd *) NULL)
2660     {
2661       relocation += symbol->section->output_section->vma;
2662       relocation += symbol->section->output_offset;
2663     }
2664
2665   relocation += reloc_entry->addend;
2666   switch (reloc_entry->howto->type)
2667     {
2668     case R_NDS32_LO12S3:
2669       relocation >>= 3;
2670       break;
2671
2672     case R_NDS32_LO12S2:
2673       relocation >>= 2;
2674       break;
2675
2676     case R_NDS32_LO12S1:
2677       relocation >>= 1;
2678       break;
2679
2680     case R_NDS32_LO12S0:
2681     default:
2682       relocation >>= 0;
2683       break;
2684     }
2685
2686   inplace_address = (bfd_byte *) data + reloc_entry->address;
2687
2688 #define DOIT(x)                                         \
2689   x = ((x & ~reloc_entry->howto->dst_mask) |            \
2690   (((x & reloc_entry->howto->src_mask) +  relocation) & \
2691   reloc_entry->howto->dst_mask))
2692
2693   switch (reloc_entry->howto->size)
2694     {
2695     case 1:
2696       {
2697         short x = bfd_getb16 (inplace_address);
2698
2699         DOIT (x);
2700         bfd_putb16 ((bfd_vma) x, inplace_address);
2701       }
2702       break;
2703     case 2:
2704       {
2705         unsigned long x = bfd_getb32 (inplace_address);
2706
2707         DOIT (x);
2708         bfd_putb32 ((bfd_vma) x, inplace_address);
2709       }
2710       break;
2711     default:
2712       BFD_ASSERT (0);
2713     }
2714
2715   if (output_bfd != (bfd *) NULL)
2716     reloc_entry->address += input_section->output_offset;
2717
2718   return ret;
2719 }
2720
2721 /* Handle the R_NDS32_SDA15 reloc.
2722    This reloc is used to compute the address of objects in the small data area
2723    and to perform loads and stores from that area.
2724    The lower 15 bits are sign extended and added to the register specified
2725    in the instruction, which is assumed to point to _SDA_BASE_.
2726
2727    Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2728    the access size, this must be taken care of.  */
2729
2730 static bfd_reloc_status_type
2731 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2732                        asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2733                        asection *input_section, bfd *output_bfd,
2734                        char **error_message ATTRIBUTE_UNUSED)
2735 {
2736   /* This part is from bfd_elf_generic_reloc.  */
2737   if (output_bfd != (bfd *) NULL
2738       && (symbol->flags & BSF_SECTION_SYM) == 0
2739       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2740     {
2741       reloc_entry->address += input_section->output_offset;
2742       return bfd_reloc_ok;
2743     }
2744
2745   if (output_bfd != NULL)
2746     {
2747       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2748       return bfd_reloc_continue;
2749     }
2750
2751   /* FIXME: not sure what to do here yet.  But then again, the linker
2752      may never call us.  */
2753   abort ();
2754 }
2755
2756 /* nds32_elf_ignore_reloc is the special function for
2757    relocation types which don't need to be relocated
2758    like relaxation relocation types.
2759    This function simply return bfd_reloc_ok when it is
2760    invoked.  */
2761
2762 static bfd_reloc_status_type
2763 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2764                         asymbol *symbol ATTRIBUTE_UNUSED,
2765                         void *data ATTRIBUTE_UNUSED, asection *input_section,
2766                         bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2767 {
2768   if (output_bfd != NULL)
2769     reloc_entry->address += input_section->output_offset;
2770
2771   return bfd_reloc_ok;
2772 }
2773 \f
2774
2775 /* Map BFD reloc types to NDS32 ELF reloc types.  */
2776
2777 struct nds32_reloc_map_entry
2778 {
2779   bfd_reloc_code_real_type bfd_reloc_val;
2780   unsigned char elf_reloc_val;
2781 };
2782
2783 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
2784 {
2785   {BFD_RELOC_NONE, R_NDS32_NONE},
2786   {BFD_RELOC_16, R_NDS32_16_RELA},
2787   {BFD_RELOC_32, R_NDS32_32_RELA},
2788   {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
2789   {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
2790   {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
2791   {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
2792   {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
2793   {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
2794   {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
2795   {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
2796   {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
2797   {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
2798   {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
2799   {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
2800   {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
2801   {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
2802   {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
2803   {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
2804   {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
2805   {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
2806   {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
2807   {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
2808
2809   {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
2810   {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
2811   {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
2812   {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
2813   {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
2814   {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
2815   {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
2816   {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
2817   {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
2818   {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
2819   {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
2820   {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
2821   {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
2822   {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
2823   {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
2824   {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
2825   {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
2826   {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
2827   {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
2828   {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
2829   {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
2830   {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
2831   {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
2832   {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
2833   {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
2834   {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
2835   {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
2836   {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
2837   {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
2838   {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
2839   {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
2840   {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
2841   {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
2842   {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
2843   {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
2844   {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
2845   {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
2846   {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
2847   {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
2848   {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
2849   {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
2850   {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
2851   {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
2852   {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
2853   {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
2854   {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
2855   {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
2856   {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
2857   {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
2858   {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
2859   {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
2860   {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
2861   {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
2862   {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
2863   {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
2864   {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
2865   {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
2866   {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
2867   {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
2868   {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
2869   {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
2870   {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
2871   {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
2872   {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
2873   {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
2874   {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
2875   {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
2876   {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
2877   {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
2878   {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
2879   {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
2880   {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
2881   {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
2882   {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
2883   {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
2884
2885   {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
2886   {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
2887   {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
2888   {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
2889   {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
2890   {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
2891   {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
2892   {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
2893   {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
2894   {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
2895   {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
2896   {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
2897   {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
2898   {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
2899   {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
2900   {BFD_RELOC_NDS32_TLS_TPOFF, R_NDS32_TLS_TPOFF},
2901   {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
2902   {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
2903   {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
2904   {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
2905 };
2906
2907 /* Patch tag.  */
2908
2909 static reloc_howto_type *
2910 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2911                                  const char *r_name)
2912 {
2913   unsigned int i;
2914
2915   for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
2916     if (nds32_elf_howto_table[i].name != NULL
2917         && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
2918       return &nds32_elf_howto_table[i];
2919
2920   for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
2921     if (nds32_elf_relax_howto_table[i].name != NULL
2922         && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
2923       return &nds32_elf_relax_howto_table[i];
2924
2925   return NULL;
2926 }
2927
2928 static reloc_howto_type *
2929 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
2930 {
2931   if (code < R_NDS32_RELAX_ENTRY)
2932     {
2933       BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
2934       return &nds32_elf_howto_table[code];
2935     }
2936   else
2937     {
2938       BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
2939                   < ARRAY_SIZE (nds32_elf_relax_howto_table));
2940       return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
2941     }
2942 }
2943
2944 static reloc_howto_type *
2945 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2946                                  bfd_reloc_code_real_type code)
2947 {
2948   unsigned int i;
2949
2950   for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
2951     {
2952       if (nds32_reloc_map[i].bfd_reloc_val == code)
2953         return bfd_elf32_bfd_reloc_type_table_lookup
2954                  (nds32_reloc_map[i].elf_reloc_val);
2955     }
2956
2957   return NULL;
2958 }
2959
2960 /* Set the howto pointer for an NDS32 ELF reloc.  */
2961
2962 static void
2963 nds32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2964                          Elf_Internal_Rela *dst)
2965 {
2966   enum elf_nds32_reloc_type r_type;
2967
2968   r_type = ELF32_R_TYPE (dst->r_info);
2969   if (r_type > R_NDS32_GNU_VTENTRY)
2970     {
2971       _bfd_error_handler (_("%B: invalid NDS32 reloc number: %d"), abfd, r_type);
2972       r_type = 0;
2973     }
2974   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2975 }
2976
2977 static void
2978 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2979                      Elf_Internal_Rela *dst)
2980 {
2981   BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2982               || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2983                   && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2984   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2985 }
2986
2987 /* Support for core dump NOTE sections.
2988    Reference to include/linux/elfcore.h in Linux.  */
2989
2990 static bfd_boolean
2991 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2992 {
2993   int offset;
2994   size_t size;
2995
2996   switch (note->descsz)
2997     {
2998     case 0x114:
2999       /* Linux/NDS32 32-bit, ABI1 */
3000
3001       /* pr_cursig */
3002       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3003
3004       /* pr_pid */
3005       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3006
3007       /* pr_reg */
3008       offset = 72;
3009       size = 200;
3010       break;
3011
3012     case 0xfc:
3013       /* Linux/NDS32 32-bit */
3014
3015       /* pr_cursig */
3016       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3017
3018       /* pr_pid */
3019       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3020
3021       /* pr_reg */
3022       offset = 72;
3023       size = 176;
3024       break;
3025
3026     default:
3027       return FALSE;
3028     }
3029
3030   /* Make a ".reg" section.  */
3031   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3032                                           size, note->descpos + offset);
3033 }
3034
3035 static bfd_boolean
3036 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3037 {
3038   switch (note->descsz)
3039     {
3040     case 124:
3041       /* Linux/NDS32 */
3042
3043       /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform.  */
3044       elf_tdata (abfd)->core->program =
3045         _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3046       elf_tdata (abfd)->core->command =
3047         _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3048
3049     default:
3050       return FALSE;
3051     }
3052
3053   /* Note that for some reason, a spurious space is tacked
3054      onto the end of the args in some (at least one anyway)
3055      implementations, so strip it off if it exists.  */
3056   {
3057     char *command = elf_tdata (abfd)->core->command;
3058     int n = strlen (command);
3059
3060     if (0 < n && command[n - 1] == ' ')
3061       command[n - 1] = '\0';
3062   }
3063
3064   return TRUE;
3065 }
3066
3067 /* Hook called by the linker routine which adds symbols from an object
3068    file.  We must handle the special NDS32 section numbers here.
3069    We also keep watching for whether we need to create the sdata special
3070    linker sections.  */
3071
3072 static bfd_boolean
3073 nds32_elf_add_symbol_hook (bfd *abfd,
3074                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3075                            Elf_Internal_Sym *sym,
3076                            const char **namep ATTRIBUTE_UNUSED,
3077                            flagword *flagsp ATTRIBUTE_UNUSED,
3078                            asection **secp, bfd_vma *valp)
3079 {
3080   switch (sym->st_shndx)
3081     {
3082     case SHN_COMMON:
3083       /* Common symbols less than the GP size are automatically
3084          treated as SHN_MIPS_SCOMMON symbols.  */
3085       if (sym->st_size > elf_gp_size (abfd)
3086           || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3087         break;
3088
3089       /* st_value is the alignemnt constraint.
3090          That might be its actual size if it is an array or structure.  */
3091       switch (sym->st_value)
3092         {
3093         case 1:
3094           *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3095           break;
3096         case 2:
3097           *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3098           break;
3099         case 4:
3100           *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3101           break;
3102         case 8:
3103           *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3104           break;
3105         default:
3106           return TRUE;
3107         }
3108
3109       (*secp)->flags |= SEC_IS_COMMON;
3110       *valp = sym->st_size;
3111       break;
3112     }
3113
3114   return TRUE;
3115 }
3116
3117
3118 /* This function can figure out the best location for a base register to access
3119    data relative to this base register
3120    INPUT:
3121    sda_d0: size of first DOUBLE WORD data section
3122    sda_w0: size of first WORD data section
3123    sda_h0: size of first HALF WORD data section
3124    sda_b : size of BYTE data section
3125    sda_hi: size of second HALF WORD data section
3126    sda_w1: size of second WORD data section
3127    sda_d1: size of second DOUBLE WORD data section
3128    OUTPUT:
3129    offset (always positive) from the beginning of sda_d0 if OK
3130    a negative error value if fail
3131    NOTE:
3132    these 7 sections have to be located back to back if exist
3133    a pass in 0 value for non-existing section   */
3134
3135 /* Due to the interpretation of simm15 field of load/store depending on
3136    data accessing size, the organization of base register relative data shall
3137    like the following figure
3138    -------------------------------------------
3139    |  DOUBLE WORD sized data (range +/- 128K)
3140    -------------------------------------------
3141    |  WORD sized data (range +/- 64K)
3142    -------------------------------------------
3143    |  HALF WORD sized data (range +/- 32K)
3144    -------------------------------------------
3145    |  BYTE sized data (range +/- 16K)
3146    -------------------------------------------
3147    |  HALF WORD sized data (range +/- 32K)
3148    -------------------------------------------
3149    |  WORD sized data (range +/- 64K)
3150    -------------------------------------------
3151    |  DOUBLE WORD sized data (range +/- 128K)
3152    -------------------------------------------
3153    Its base register shall be set to access these data freely.  */
3154
3155 /* We have to figure out the SDA_BASE value, so that we can adjust the
3156    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
3157    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
3158    target data.  We don't need to adjust the symbol value for an
3159    external symbol if we are producing relocatable output.  */
3160
3161 static asection *sda_rela_sec = NULL;
3162
3163 #define SDA_SECTION_NUM 10
3164
3165 static bfd_reloc_status_type
3166 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3167                           bfd_vma *psb, bfd_boolean add_symbol)
3168 {
3169   int relax_fp_as_gp;
3170   struct elf_nds32_link_hash_table *table;
3171   struct bfd_link_hash_entry *h, *h2;
3172   long unsigned int total = 0;
3173
3174   h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3175   if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3176     {
3177       asection *first = NULL, *final = NULL, *temp;
3178       bfd_vma sda_base;
3179       /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3180          4 byte-aligned.  Therefore, it has to set the first section ".data"
3181          4 byte-aligned.  */
3182       static const char sec_name[SDA_SECTION_NUM][10] =
3183         {
3184           ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3185           ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3186         };
3187       size_t i = 0;
3188
3189       if (output_bfd->sections == NULL)
3190         {
3191           *psb = elf_gp (output_bfd);
3192           return bfd_reloc_ok;
3193         }
3194
3195       /* Get the first and final section.  */
3196       while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3197         {
3198           temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3199           if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3200             first = temp;
3201           if (temp && (temp->size != 0 || temp->rawsize != 0))
3202             final = temp;
3203
3204           /* Summarize the sections in order to check if joining .bss.  */
3205           if (temp && temp->size != 0)
3206             total += temp->size;
3207           else if (temp && temp->rawsize != 0)
3208             total += temp->rawsize;
3209
3210           i++;
3211         }
3212
3213       /* Check .bss size.  */
3214       temp = bfd_get_section_by_name (output_bfd, ".bss");
3215       if (temp)
3216         {
3217           if (temp->size != 0)
3218             total += temp->size;
3219           else if (temp->rawsize != 0)
3220             total += temp->rawsize;
3221
3222           if (total < 0x80000)
3223             {
3224               if (!first && (temp->size != 0 || temp->rawsize != 0))
3225                 first = temp;
3226               if ((temp->size != 0 || temp->rawsize != 0))
3227                 final = temp;
3228             }
3229         }
3230
3231       if (first && final)
3232         {
3233           /* The middle of data region.  */
3234           sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3235
3236           /* Find the section sda_base located.  */
3237           i = 0;
3238           while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3239             {
3240               final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3241               if (final && (final->size != 0 || final->rawsize != 0)
3242                   && sda_base >= final->vma)
3243                 {
3244                   first = final;
3245                   i++;
3246                 }
3247               else
3248                 break;
3249             }
3250         }
3251       else
3252         {
3253           /* There is not any data section in output bfd, and set _SDA_BASE_ in
3254              first output section.  */
3255           first = output_bfd->sections;
3256           while (first && first->size == 0 && first->rawsize == 0)
3257             first = first->next;
3258           if (!first)
3259             {
3260               *psb = elf_gp (output_bfd);
3261               return bfd_reloc_ok;
3262             }
3263           sda_base = first->vma + first->rawsize;
3264         }
3265
3266       sda_base -= first->vma;
3267       sda_base = sda_base & (~7);
3268
3269       if (!_bfd_generic_link_add_one_symbol
3270              (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3271               (bfd_vma) sda_base, (const char *) NULL, FALSE,
3272               get_elf_backend_data (output_bfd)->collect, &h))
3273         return FALSE;
3274
3275       sda_rela_sec = first;
3276
3277       table = nds32_elf_hash_table (info);
3278       relax_fp_as_gp = table->relax_fp_as_gp;
3279       if (relax_fp_as_gp)
3280         {
3281           h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3282                                      FALSE, FALSE, FALSE);
3283           /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3284              And set FP equal to SDA_BASE to do relaxation for
3285              la $fp, _FP_BASE_.  */
3286           if (!_bfd_generic_link_add_one_symbol
3287                  (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3288                   first, (bfd_vma) sda_base, (const char *) NULL,
3289                   FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3290             return FALSE;
3291         }
3292     }
3293
3294   if (add_symbol == TRUE)
3295     {
3296       if (h)
3297         {
3298           /* Now set gp.  */
3299           elf_gp (output_bfd) = (h->u.def.value
3300                                  + h->u.def.section->output_section->vma
3301                                  + h->u.def.section->output_offset);
3302         }
3303       else
3304         {
3305           (*_bfd_error_handler) (_("error: Can't find symbol: _SDA_BASE_."));
3306           return bfd_reloc_dangerous;
3307         }
3308     }
3309
3310   *psb = h->u.def.value + h->u.def.section->output_section->vma
3311          + h->u.def.section->output_offset;
3312   return bfd_reloc_ok;
3313 }
3314 \f
3315
3316 /* Return size of a PLT entry.  */
3317 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3318
3319
3320 /* Create an entry in an nds32 ELF linker hash table.  */
3321
3322 static struct bfd_hash_entry *
3323 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3324                              struct bfd_hash_table *table,
3325                              const char *string)
3326 {
3327   struct elf_nds32_link_hash_entry *ret;
3328
3329   ret = (struct elf_nds32_link_hash_entry *) entry;
3330
3331   /* Allocate the structure if it has not already been allocated by a
3332      subclass.  */
3333   if (ret == NULL)
3334     ret = (struct elf_nds32_link_hash_entry *)
3335        bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3336
3337   if (ret == NULL)
3338     return (struct bfd_hash_entry *) ret;
3339
3340   /* Call the allocation method of the superclass.  */
3341   ret = (struct elf_nds32_link_hash_entry *)
3342     _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3343
3344   if (ret != NULL)
3345     {
3346       struct elf_nds32_link_hash_entry *eh;
3347
3348       eh = (struct elf_nds32_link_hash_entry *) ret;
3349       eh->dyn_relocs = NULL;
3350       eh->tls_type = GOT_UNKNOWN;
3351     }
3352
3353   return (struct bfd_hash_entry *) ret;
3354 }
3355
3356 /* Create an nds32 ELF linker hash table.  */
3357
3358 static struct bfd_link_hash_table *
3359 nds32_elf_link_hash_table_create (bfd *abfd)
3360 {
3361   struct elf_nds32_link_hash_table *ret;
3362
3363   bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3364
3365   ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3366   if (ret == NULL)
3367     return NULL;
3368
3369   /* patch tag.  */
3370   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3371                                       nds32_elf_link_hash_newfunc,
3372                                       sizeof (struct elf_nds32_link_hash_entry),
3373                                       NDS32_ELF_DATA))
3374     {
3375       free (ret);
3376       return NULL;
3377     }
3378
3379   ret->sgot = NULL;
3380   ret->sgotplt = NULL;
3381   ret->srelgot = NULL;
3382   ret->splt = NULL;
3383   ret->srelplt = NULL;
3384   ret->sdynbss = NULL;
3385   ret->srelbss = NULL;
3386   ret->sym_ld_script = NULL;
3387   ret->ex9_export_file = NULL;
3388   ret->ex9_import_file = NULL;
3389
3390   return &ret->root.root;
3391 }
3392
3393 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3394    shortcuts to them in our hash table.  */
3395
3396 static bfd_boolean
3397 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3398 {
3399   struct elf_nds32_link_hash_table *htab;
3400
3401   if (!_bfd_elf_create_got_section (dynobj, info))
3402     return FALSE;
3403
3404   htab = nds32_elf_hash_table (info);
3405   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3406   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3407   if (!htab->sgot || !htab->sgotplt)
3408     abort ();
3409
3410   /* _bfd_elf_create_got_section will create it for us.  */
3411   htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3412   if (htab->srelgot == NULL
3413       || !bfd_set_section_flags (dynobj, htab->srelgot,
3414                                  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3415                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED
3416                                   | SEC_READONLY))
3417       || !bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3418     return FALSE;
3419
3420   return TRUE;
3421 }
3422
3423 /* Create dynamic sections when linking against a dynamic object.  */
3424
3425 static bfd_boolean
3426 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3427 {
3428   struct elf_nds32_link_hash_table *htab;
3429   flagword flags, pltflags;
3430   register asection *s;
3431   const struct elf_backend_data *bed;
3432   int ptralign = 2;             /* 32-bit  */
3433
3434   bed = get_elf_backend_data (abfd);
3435
3436   htab = nds32_elf_hash_table (info);
3437
3438   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3439      .rel[a].bss sections.  */
3440
3441   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3442            | SEC_LINKER_CREATED);
3443
3444   pltflags = flags;
3445   pltflags |= SEC_CODE;
3446   if (bed->plt_not_loaded)
3447     pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3448   if (bed->plt_readonly)
3449     pltflags |= SEC_READONLY;
3450
3451   s = bfd_make_section (abfd, ".plt");
3452   htab->splt = s;
3453   if (s == NULL
3454       || !bfd_set_section_flags (abfd, s, pltflags)
3455       || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3456     return FALSE;
3457
3458   if (bed->want_plt_sym)
3459     {
3460       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3461          .plt section.  */
3462       struct bfd_link_hash_entry *bh = NULL;
3463       struct elf_link_hash_entry *h;
3464
3465       if (!(_bfd_generic_link_add_one_symbol
3466             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3467              (bfd_vma) 0, (const char *) NULL, FALSE,
3468              get_elf_backend_data (abfd)->collect, &bh)))
3469         return FALSE;
3470
3471       h = (struct elf_link_hash_entry *) bh;
3472       h->def_regular = 1;
3473       h->type = STT_OBJECT;
3474
3475       if (info->shared && !bfd_elf_link_record_dynamic_symbol (info, h))
3476         return FALSE;
3477     }
3478
3479   s = bfd_make_section (abfd,
3480                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3481   htab->srelplt = s;
3482   if (s == NULL
3483       || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3484       || !bfd_set_section_alignment (abfd, s, ptralign))
3485     return FALSE;
3486
3487   if (htab->sgot == NULL && !create_got_section (abfd, info))
3488     return FALSE;
3489
3490   {
3491     const char *secname;
3492     char *relname;
3493     flagword secflags;
3494     asection *sec;
3495
3496     for (sec = abfd->sections; sec; sec = sec->next)
3497       {
3498         secflags = bfd_get_section_flags (abfd, sec);
3499         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3500             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3501           continue;
3502         secname = bfd_get_section_name (abfd, sec);
3503         relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3504         strcpy (relname, ".rela");
3505         strcat (relname, secname);
3506         if (bfd_get_section_by_name (abfd, secname))
3507           continue;
3508         s = bfd_make_section (abfd, relname);
3509         if (s == NULL
3510             || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3511             || !bfd_set_section_alignment (abfd, s, ptralign))
3512           return FALSE;
3513       }
3514   }
3515
3516   if (bed->want_dynbss)
3517     {
3518       /* The .dynbss section is a place to put symbols which are defined
3519          by dynamic objects, are referenced by regular objects, and are
3520          not functions.  We must allocate space for them in the process
3521          image and use a R_*_COPY reloc to tell the dynamic linker to
3522          initialize them at run time.  The linker script puts the .dynbss
3523          section into the .bss section of the final image.  */
3524       s = bfd_make_section (abfd, ".dynbss");
3525       htab->sdynbss = s;
3526       if (s == NULL
3527           || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3528         return FALSE;
3529       /* The .rel[a].bss section holds copy relocs.  This section is not
3530          normally needed.  We need to create it here, though, so that the
3531          linker will map it to an output section.  We can't just create it
3532          only if we need it, because we will not know whether we need it
3533          until we have seen all the input files, and the first time the
3534          main linker code calls BFD after examining all the input files
3535          (size_dynamic_sections) the input sections have already been
3536          mapped to the output sections.  If the section turns out not to
3537          be needed, we can discard it later.  We will never need this
3538          section when generating a shared object, since they do not use
3539          copy relocs.  */
3540       if (!info->shared)
3541         {
3542           s = bfd_make_section (abfd, (bed->default_use_rela_p
3543                                        ? ".rela.bss" : ".rel.bss"));
3544           htab->srelbss = s;
3545           if (s == NULL
3546               || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3547               || !bfd_set_section_alignment (abfd, s, ptralign))
3548             return FALSE;
3549         }
3550     }
3551
3552   return TRUE;
3553 }
3554
3555 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3556 static void
3557 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3558                                 struct elf_link_hash_entry *dir,
3559                                 struct elf_link_hash_entry *ind)
3560 {
3561   struct elf_nds32_link_hash_entry *edir, *eind;
3562
3563   edir = (struct elf_nds32_link_hash_entry *) dir;
3564   eind = (struct elf_nds32_link_hash_entry *) ind;
3565
3566   if (eind->dyn_relocs != NULL)
3567     {
3568       if (edir->dyn_relocs != NULL)
3569         {
3570           struct elf_nds32_dyn_relocs **pp;
3571           struct elf_nds32_dyn_relocs *p;
3572
3573           if (ind->root.type == bfd_link_hash_indirect)
3574             abort ();
3575
3576           /* Add reloc counts against the weak sym to the strong sym
3577              list.  Merge any entries against the same section.  */
3578           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3579             {
3580               struct elf_nds32_dyn_relocs *q;
3581
3582               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3583                 if (q->sec == p->sec)
3584                   {
3585                     q->pc_count += p->pc_count;
3586                     q->count += p->count;
3587                     *pp = p->next;
3588                     break;
3589                   }
3590               if (q == NULL)
3591                 pp = &p->next;
3592             }
3593           *pp = edir->dyn_relocs;
3594         }
3595
3596       edir->dyn_relocs = eind->dyn_relocs;
3597       eind->dyn_relocs = NULL;
3598     }
3599
3600   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3601 }
3602 \f
3603
3604 /* Adjust a symbol defined by a dynamic object and referenced by a
3605    regular object.  The current definition is in some section of the
3606    dynamic object, but we're not including those sections.  We have to
3607    change the definition to something the rest of the link can
3608    understand.  */
3609
3610 static bfd_boolean
3611 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3612                                  struct elf_link_hash_entry *h)
3613 {
3614   struct elf_nds32_link_hash_table *htab;
3615   struct elf_nds32_link_hash_entry *eh;
3616   struct elf_nds32_dyn_relocs *p;
3617   bfd *dynobj;
3618   asection *s;
3619   unsigned int power_of_two;
3620
3621   dynobj = elf_hash_table (info)->dynobj;
3622
3623   /* Make sure we know what is going on here.  */
3624   BFD_ASSERT (dynobj != NULL
3625               && (h->needs_plt
3626                   || h->u.weakdef != NULL
3627                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3628
3629
3630   /* If this is a function, put it in the procedure linkage table.  We
3631      will fill in the contents of the procedure linkage table later,
3632      when we know the address of the .got section.  */
3633   if (h->type == STT_FUNC || h->needs_plt)
3634     {
3635       if (!info->shared
3636           && !h->def_dynamic
3637           && !h->ref_dynamic
3638           && h->root.type != bfd_link_hash_undefweak
3639           && h->root.type != bfd_link_hash_undefined)
3640         {
3641           /* This case can occur if we saw a PLT reloc in an input
3642              file, but the symbol was never referred to by a dynamic
3643              object.  In such a case, we don't actually need to build
3644              a procedure linkage table, and we can just do a PCREL
3645              reloc instead.  */
3646           h->plt.offset = (bfd_vma) - 1;
3647           h->needs_plt = 0;
3648         }
3649
3650       return TRUE;
3651     }
3652   else
3653     h->plt.offset = (bfd_vma) - 1;
3654
3655   /* If this is a weak symbol, and there is a real definition, the
3656      processor independent code will have arranged for us to see the
3657      real definition first, and we can just use the same value.  */
3658   if (h->u.weakdef != NULL)
3659     {
3660       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3661                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3662       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3663       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3664       return TRUE;
3665     }
3666
3667   /* This is a reference to a symbol defined by a dynamic object which
3668      is not a function.  */
3669
3670   /* If we are creating a shared library, we must presume that the
3671      only references to the symbol are via the global offset table.
3672      For such cases we need not do anything here; the relocations will
3673      be handled correctly by relocate_section.  */
3674   if (info->shared)
3675     return TRUE;
3676
3677   /* If there are no references to this symbol that do not use the
3678      GOT, we don't need to generate a copy reloc.  */
3679   if (!h->non_got_ref)
3680     return TRUE;
3681
3682   /* If -z nocopyreloc was given, we won't generate them either.  */
3683   if (info->nocopyreloc)
3684     {
3685       h->non_got_ref = 0;
3686       return TRUE;
3687     }
3688
3689   eh = (struct elf_nds32_link_hash_entry *) h;
3690   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3691     {
3692       s = p->sec->output_section;
3693       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3694         break;
3695     }
3696
3697   /* If we didn't find any dynamic relocs in sections which needs the
3698      copy reloc, then we'll be keeping the dynamic relocs and avoiding
3699      the copy reloc.  */
3700   if (p == NULL)
3701     {
3702       h->non_got_ref = 0;
3703       return TRUE;
3704     }
3705
3706   /* We must allocate the symbol in our .dynbss section, which will
3707      become part of the .bss section of the executable.  There will be
3708      an entry for this symbol in the .dynsym section.  The dynamic
3709      object will contain position independent code, so all references
3710      from the dynamic object to this symbol will go through the global
3711      offset table.  The dynamic linker will use the .dynsym entry to
3712      determine the address it must put in the global offset table, so
3713      both the dynamic object and the regular object will refer to the
3714      same memory location for the variable.  */
3715
3716   htab = nds32_elf_hash_table (info);
3717   s = htab->sdynbss;
3718   BFD_ASSERT (s != NULL);
3719
3720   /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3721      to copy the initial value out of the dynamic object and into the
3722      runtime process image.  We need to remember the offset into the
3723      .rela.bss section we are going to use.  */
3724   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3725     {
3726       asection *srel;
3727
3728       srel = htab->srelbss;
3729       BFD_ASSERT (srel != NULL);
3730       srel->size += sizeof (Elf32_External_Rela);
3731       h->needs_copy = 1;
3732     }
3733
3734   /* We need to figure out the alignment required for this symbol.  I
3735      have no idea how ELF linkers handle this.  */
3736   power_of_two = bfd_log2 (h->size);
3737   if (power_of_two > 3)
3738     power_of_two = 3;
3739
3740   /* Apply the required alignment.  */
3741   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3742   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3743     {
3744       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3745         return FALSE;
3746     }
3747
3748   /* Define the symbol as being at this point in the section.  */
3749   h->root.u.def.section = s;
3750   h->root.u.def.value = s->size;
3751
3752   /* Increment the section size to make room for the symbol.  */
3753   s->size += h->size;
3754
3755   return TRUE;
3756 }
3757
3758 /* Allocate space in .plt, .got and associated reloc sections for
3759    dynamic relocs.  */
3760
3761 static bfd_boolean
3762 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3763 {
3764   struct bfd_link_info *info;
3765   struct elf_nds32_link_hash_table *htab;
3766   struct elf_nds32_link_hash_entry *eh;
3767   struct elf_nds32_dyn_relocs *p;
3768
3769   if (h->root.type == bfd_link_hash_indirect)
3770     return TRUE;
3771
3772   if (h->root.type == bfd_link_hash_warning)
3773     /* When warning symbols are created, they **replace** the "real"
3774        entry in the hash table, thus we never get to see the real
3775        symbol in a hash traversal.  So look at it now.  */
3776     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3777
3778   info = (struct bfd_link_info *) inf;
3779   htab = nds32_elf_hash_table (info);
3780
3781   eh = (struct elf_nds32_link_hash_entry *) h;
3782
3783   if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3784     {
3785       /* Make sure this symbol is output as a dynamic symbol.
3786          Undefined weak syms won't yet be marked as dynamic.  */
3787       if (h->dynindx == -1 && !h->forced_local)
3788         {
3789           if (!bfd_elf_link_record_dynamic_symbol (info, h))
3790             return FALSE;
3791         }
3792
3793       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
3794         {
3795           asection *s = htab->splt;
3796
3797           /* If this is the first .plt entry, make room for the special
3798              first entry.  */
3799           if (s->size == 0)
3800             s->size += PLT_ENTRY_SIZE;
3801
3802           h->plt.offset = s->size;
3803
3804           /* If this symbol is not defined in a regular file, and we are
3805              not generating a shared library, then set the symbol to this
3806              location in the .plt.  This is required to make function
3807              pointers compare as equal between the normal executable and
3808              the shared library.  */
3809           if (!info->shared && !h->def_regular)
3810             {
3811               h->root.u.def.section = s;
3812               h->root.u.def.value = h->plt.offset;
3813             }
3814
3815           /* Make room for this entry.  */
3816           s->size += PLT_ENTRY_SIZE;
3817
3818           /* We also need to make an entry in the .got.plt section, which
3819              will be placed in the .got section by the linker script.  */
3820           htab->sgotplt->size += 4;
3821
3822           /* We also need to make an entry in the .rel.plt section.  */
3823           htab->srelplt->size += sizeof (Elf32_External_Rela);
3824         }
3825       else
3826         {
3827           h->plt.offset = (bfd_vma) - 1;
3828           h->needs_plt = 0;
3829         }
3830     }
3831   else
3832     {
3833       h->plt.offset = (bfd_vma) - 1;
3834       h->needs_plt = 0;
3835     }
3836
3837   if (h->got.refcount > 0)
3838     {
3839       asection *s;
3840       bfd_boolean dyn;
3841       int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3842
3843       /* Make sure this symbol is output as a dynamic symbol.
3844          Undefined weak syms won't yet be marked as dynamic.  */
3845       if (h->dynindx == -1 && !h->forced_local)
3846         {
3847           if (!bfd_elf_link_record_dynamic_symbol (info, h))
3848             return FALSE;
3849         }
3850
3851       s = htab->sgot;
3852       h->got.offset = s->size;
3853
3854       if (tls_type == GOT_UNKNOWN)
3855         abort ();
3856       else if (tls_type == GOT_NORMAL
3857                || tls_type == GOT_TLS_IE)
3858         /* Need a GOT slot.  */
3859         s->size += 4;
3860
3861       dyn = htab->root.dynamic_sections_created;
3862       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
3863         htab->srelgot->size += sizeof (Elf32_External_Rela);
3864     }
3865   else
3866     h->got.offset = (bfd_vma) - 1;
3867
3868   if (eh->dyn_relocs == NULL)
3869     return TRUE;
3870
3871   /* In the shared -Bsymbolic case, discard space allocated for
3872      dynamic pc-relative relocs against symbols which turn out to be
3873      defined in regular objects.  For the normal shared case, discard
3874      space for pc-relative relocs that have become local due to symbol
3875      visibility changes.  */
3876
3877   if (info->shared)
3878     {
3879       if (h->def_regular && (h->forced_local || info->symbolic))
3880         {
3881           struct elf_nds32_dyn_relocs **pp;
3882
3883           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3884             {
3885               p->count -= p->pc_count;
3886               p->pc_count = 0;
3887               if (p->count == 0)
3888                 *pp = p->next;
3889               else
3890                 pp = &p->next;
3891             }
3892         }
3893     }
3894   else
3895     {
3896       /* For the non-shared case, discard space for relocs against
3897          symbols which turn out to need copy relocs or are not dynamic.  */
3898
3899       if (!h->non_got_ref
3900           && ((h->def_dynamic
3901                && !h->def_regular)
3902               || (htab->root.dynamic_sections_created
3903                   && (h->root.type == bfd_link_hash_undefweak
3904                       || h->root.type == bfd_link_hash_undefined))))
3905         {
3906           /* Make sure this symbol is output as a dynamic symbol.
3907              Undefined weak syms won't yet be marked as dynamic.  */
3908           if (h->dynindx == -1 && !h->forced_local)
3909             {
3910               if (!bfd_elf_link_record_dynamic_symbol (info, h))
3911                 return FALSE;
3912             }
3913
3914           /* If that succeeded, we know we'll be keeping all the
3915              relocs.  */
3916           if (h->dynindx != -1)
3917             goto keep;
3918         }
3919
3920       eh->dyn_relocs = NULL;
3921
3922     keep:;
3923     }
3924
3925   /* Finally, allocate space.  */
3926   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3927     {
3928       asection *sreloc = elf_section_data (p->sec)->sreloc;
3929       sreloc->size += p->count * sizeof (Elf32_External_Rela);
3930     }
3931
3932   return TRUE;
3933 }
3934
3935 /* Find any dynamic relocs that apply to read-only sections.  */
3936
3937 static bfd_boolean
3938 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3939 {
3940   struct elf_nds32_link_hash_entry *eh;
3941   struct elf_nds32_dyn_relocs *p;
3942
3943   if (h->root.type == bfd_link_hash_warning)
3944     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3945
3946   eh = (struct elf_nds32_link_hash_entry *) h;
3947   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3948     {
3949       asection *s = p->sec->output_section;
3950
3951       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3952         {
3953           struct bfd_link_info *info = (struct bfd_link_info *) inf;
3954
3955           info->flags |= DF_TEXTREL;
3956
3957           /* Not an error, just cut short the traversal.  */
3958           return FALSE;
3959         }
3960     }
3961   return TRUE;
3962 }
3963
3964 /* Set the sizes of the dynamic sections.  */
3965
3966 static bfd_boolean
3967 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3968                                  struct bfd_link_info *info)
3969 {
3970   struct elf_nds32_link_hash_table *htab;
3971   bfd *dynobj;
3972   asection *s;
3973   bfd_boolean relocs;
3974   bfd *ibfd;
3975
3976   htab = nds32_elf_hash_table (info);
3977   dynobj = htab->root.dynobj;
3978   BFD_ASSERT (dynobj != NULL);
3979
3980   if (htab->root.dynamic_sections_created)
3981     {
3982       /* Set the contents of the .interp section to the interpreter.  */
3983       if (!info->shared)
3984         {
3985           s = bfd_get_section_by_name (dynobj, ".interp");
3986           BFD_ASSERT (s != NULL);
3987           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3988           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3989         }
3990     }
3991
3992   /* Set up .got offsets for local syms, and space for local dynamic
3993      relocs.  */
3994   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3995     {
3996       bfd_signed_vma *local_got;
3997       bfd_signed_vma *end_local_got;
3998       bfd_size_type locsymcount;
3999       Elf_Internal_Shdr *symtab_hdr;
4000       asection *srel;
4001
4002       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4003         continue;
4004
4005       for (s = ibfd->sections; s != NULL; s = s->next)
4006         {
4007           struct elf_nds32_dyn_relocs *p;
4008
4009           for (p = ((struct elf_nds32_dyn_relocs *)
4010                     elf_section_data (s)->local_dynrel);
4011                p != NULL; p = p->next)
4012             {
4013               if (!bfd_is_abs_section (p->sec)
4014                   && bfd_is_abs_section (p->sec->output_section))
4015                 {
4016                   /* Input section has been discarded, either because
4017                      it is a copy of a linkonce section or due to
4018                      linker script /DISCARD/, so we'll be discarding
4019                      the relocs too.  */
4020                 }
4021               else if (p->count != 0)
4022                 {
4023                   srel = elf_section_data (p->sec)->sreloc;
4024                   srel->size += p->count * sizeof (Elf32_External_Rela);
4025                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4026                     info->flags |= DF_TEXTREL;
4027                 }
4028             }
4029         }
4030
4031       local_got = elf_local_got_refcounts (ibfd);
4032       if (!local_got)
4033         continue;
4034
4035       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4036       locsymcount = symtab_hdr->sh_info;
4037       end_local_got = local_got + locsymcount;
4038       s = htab->sgot;
4039       srel = htab->srelgot;
4040       for (; local_got < end_local_got; ++local_got)
4041         {
4042           if (*local_got > 0)
4043             {
4044               *local_got = s->size;
4045               s->size += 4;
4046               if (info->shared)
4047                 srel->size += sizeof (Elf32_External_Rela);
4048             }
4049           else
4050             *local_got = (bfd_vma) - 1;
4051         }
4052     }
4053
4054   /* Allocate global sym .plt and .got entries, and space for global
4055      sym dynamic relocs.  */
4056   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4057
4058   /* We now have determined the sizes of the various dynamic sections.
4059      Allocate memory for them.  */
4060   relocs = FALSE;
4061   for (s = dynobj->sections; s != NULL; s = s->next)
4062     {
4063       if ((s->flags & SEC_LINKER_CREATED) == 0)
4064         continue;
4065
4066       if (s == htab->splt)
4067         {
4068           /* Strip this section if we don't need it; see the
4069              comment below.  */
4070         }
4071       else if (s == htab->sgot)
4072         {
4073           got_size += s->size;
4074         }
4075       else if (s == htab->sgotplt)
4076         {
4077           got_size += s->size;
4078         }
4079       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4080         {
4081           if (s->size != 0 && s != htab->srelplt)
4082             relocs = TRUE;
4083
4084           /* We use the reloc_count field as a counter if we need
4085              to copy relocs into the output file.  */
4086           s->reloc_count = 0;
4087         }
4088       else
4089         {
4090           /* It's not one of our sections, so don't allocate space.  */
4091           continue;
4092         }
4093
4094       if (s->size == 0)
4095         {
4096           /* If we don't need this section, strip it from the
4097              output file.  This is mostly to handle .rela.bss and
4098              .rela.plt.  We must create both sections in
4099              create_dynamic_sections, because they must be created
4100              before the linker maps input sections to output
4101              sections.  The linker does that before
4102              adjust_dynamic_symbol is called, and it is that
4103              function which decides whether anything needs to go
4104              into these sections.  */
4105           s->flags |= SEC_EXCLUDE;
4106           continue;
4107         }
4108
4109       /* Allocate memory for the section contents.  We use bfd_zalloc
4110          here in case unused entries are not reclaimed before the
4111          section's contents are written out.  This should not happen,
4112          but this way if it does, we get a R_NDS32_NONE reloc instead
4113          of garbage.  */
4114       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4115       if (s->contents == NULL)
4116         return FALSE;
4117     }
4118
4119
4120   if (htab->root.dynamic_sections_created)
4121     {
4122       /* Add some entries to the .dynamic section.  We fill in the
4123          values later, in nds32_elf_finish_dynamic_sections, but we
4124          must add the entries now so that we get the correct size for
4125          the .dynamic section.  The DT_DEBUG entry is filled in by the
4126          dynamic linker and used by the debugger.  */
4127 #define add_dynamic_entry(TAG, VAL) \
4128   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4129
4130       if (!info->shared)
4131         {
4132           if (!add_dynamic_entry (DT_DEBUG, 0))
4133             return FALSE;
4134         }
4135
4136       if (htab->splt->size != 0)
4137         {
4138           if (!add_dynamic_entry (DT_PLTGOT, 0)
4139               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4140               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4141               || !add_dynamic_entry (DT_JMPREL, 0))
4142             return FALSE;
4143         }
4144
4145       if (relocs)
4146         {
4147           if (!add_dynamic_entry (DT_RELA, 0)
4148               || !add_dynamic_entry (DT_RELASZ, 0)
4149               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4150             return FALSE;
4151
4152           /* If any dynamic relocs apply to a read-only section,
4153              then we need a DT_TEXTREL entry.  */
4154           if ((info->flags & DF_TEXTREL) == 0)
4155             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4156                                     (void *) info);
4157
4158           if ((info->flags & DF_TEXTREL) != 0)
4159             {
4160               if (!add_dynamic_entry (DT_TEXTREL, 0))
4161                 return FALSE;
4162             }
4163         }
4164     }
4165 #undef add_dynamic_entry
4166
4167   return TRUE;
4168 }
4169
4170 static bfd_reloc_status_type
4171 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4172                          bfd_vma relocation, bfd_byte *location)
4173 {
4174   int size;
4175   bfd_vma x = 0;
4176   bfd_reloc_status_type flag;
4177   unsigned int rightshift = howto->rightshift;
4178   unsigned int bitpos = howto->bitpos;
4179
4180   /* If the size is negative, negate RELOCATION.  This isn't very
4181      general.  */
4182   if (howto->size < 0)
4183     relocation = -relocation;
4184
4185   /* Get the value we are going to relocate.  */
4186   size = bfd_get_reloc_size (howto);
4187   switch (size)
4188     {
4189     default:
4190       abort ();
4191       break;
4192     case 0:
4193       return bfd_reloc_ok;
4194     case 2:
4195       x = bfd_getb16 (location);
4196       break;
4197     case 4:
4198       x = bfd_getb32 (location);
4199       break;
4200     }
4201
4202   /* Check for overflow.  FIXME: We may drop bits during the addition
4203      which we don't check for.  We must either check at every single
4204      operation, which would be tedious, or we must do the computations
4205      in a type larger than bfd_vma, which would be inefficient.  */
4206   flag = bfd_reloc_ok;
4207   if (howto->complain_on_overflow != complain_overflow_dont)
4208     {
4209       bfd_vma addrmask, fieldmask, signmask, ss;
4210       bfd_vma a, b, sum;
4211
4212       /* Get the values to be added together.  For signed and unsigned
4213          relocations, we assume that all values should be truncated to
4214          the size of an address.  For bitfields, all the bits matter.
4215          See also bfd_check_overflow.  */
4216       fieldmask = N_ONES (howto->bitsize);
4217       signmask = ~fieldmask;
4218       addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4219       a = (relocation & addrmask) >> rightshift;
4220       b = (x & howto->src_mask & addrmask) >> bitpos;
4221
4222       switch (howto->complain_on_overflow)
4223         {
4224         case complain_overflow_signed:
4225           /* If any sign bits are set, all sign bits must be set.
4226              That is, A must be a valid negative address after
4227              shifting.  */
4228           signmask = ~(fieldmask >> 1);
4229           /* Fall through.  */
4230
4231         case complain_overflow_bitfield:
4232           /* Much like the signed check, but for a field one bit
4233              wider.  We allow a bitfield to represent numbers in the
4234              range -2**n to 2**n-1, where n is the number of bits in the
4235              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
4236              can't overflow, which is exactly what we want.  */
4237           ss = a & signmask;
4238           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4239             flag = bfd_reloc_overflow;
4240
4241           /* We only need this next bit of code if the sign bit of B
4242              is below the sign bit of A.  This would only happen if
4243              SRC_MASK had fewer bits than BITSIZE.  Note that if
4244              SRC_MASK has more bits than BITSIZE, we can get into
4245              trouble; we would need to verify that B is in range, as
4246              we do for A above.  */
4247           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4248           ss >>= bitpos;
4249
4250           /* Set all the bits above the sign bit.  */
4251           b = (b ^ ss) - ss;
4252
4253           /* Now we can do the addition.  */
4254           sum = a + b;
4255
4256           /* See if the result has the correct sign.  Bits above the
4257              sign bit are junk now; ignore them.  If the sum is
4258              positive, make sure we did not have all negative inputs;
4259              if the sum is negative, make sure we did not have all
4260              positive inputs.  The test below looks only at the sign
4261              bits, and it really just
4262              SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4263
4264              We mask with addrmask here to explicitly allow an address
4265              wrap-around.  The Linux kernel relies on it, and it is
4266              the only way to write assembler code which can run when
4267              loaded at a location 0x80000000 away from the location at
4268              which it is linked.  */
4269           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4270             flag = bfd_reloc_overflow;
4271
4272           break;
4273
4274         case complain_overflow_unsigned:
4275           /* Checking for an unsigned overflow is relatively easy:
4276              trim the addresses and add, and trim the result as well.
4277              Overflow is normally indicated when the result does not
4278              fit in the field.  However, we also need to consider the
4279              case when, e.g., fieldmask is 0x7fffffff or smaller, an
4280              input is 0x80000000, and bfd_vma is only 32 bits; then we
4281              will get sum == 0, but there is an overflow, since the
4282              inputs did not fit in the field.  Instead of doing a
4283              separate test, we can check for this by or-ing in the
4284              operands when testing for the sum overflowing its final
4285              field.  */
4286           sum = (a + b) & addrmask;
4287           if ((a | b | sum) & signmask)
4288             flag = bfd_reloc_overflow;
4289           break;
4290
4291         default:
4292           abort ();
4293         }
4294     }
4295
4296   /* Put RELOCATION in the right bits.  */
4297   relocation >>= (bfd_vma) rightshift;
4298   relocation <<= (bfd_vma) bitpos;
4299
4300   /* Add RELOCATION to the right bits of X.  */
4301   /* FIXME : 090616
4302      Because the relaxation may generate duplicate relocation at one address,
4303      an addition to immediate in the instruction may cause the relocation added
4304      several times.
4305      This bug should be fixed in assembler, but a check is also needed here.  */
4306   if (howto->partial_inplace)
4307     x = ((x & ~howto->dst_mask)
4308          | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4309   else
4310     x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4311
4312
4313   /* Put the relocated value back in the object file.  */
4314   switch (size)
4315     {
4316     default:
4317     case 0:
4318     case 1:
4319     case 8:
4320       abort ();
4321       break;
4322     case 2:
4323       bfd_putb16 (x, location);
4324       break;
4325     case 4:
4326       bfd_putb32 (x, location);
4327       break;
4328     }
4329
4330   return flag;
4331 }
4332
4333 static bfd_reloc_status_type
4334 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4335                                asection *input_section, bfd_byte *contents,
4336                                bfd_vma address, bfd_vma value, bfd_vma addend)
4337 {
4338   bfd_vma relocation;
4339
4340   /* Sanity check the address.  */
4341   if (address > bfd_get_section_limit (input_bfd, input_section))
4342     return bfd_reloc_outofrange;
4343
4344   /* This function assumes that we are dealing with a basic relocation
4345      against a symbol.  We want to compute the value of the symbol to
4346      relocate to.  This is just VALUE, the value of the symbol, plus
4347      ADDEND, any addend associated with the reloc.  */
4348   relocation = value + addend;
4349
4350   /* If the relocation is PC relative, we want to set RELOCATION to
4351      the distance between the symbol (currently in RELOCATION) and the
4352      location we are relocating.  Some targets (e.g., i386-aout)
4353      arrange for the contents of the section to be the negative of the
4354      offset of the location within the section; for such targets
4355      pcrel_offset is FALSE.  Other targets (e.g., m88kbcs or ELF)
4356      simply leave the contents of the section as zero; for such
4357      targets pcrel_offset is TRUE.  If pcrel_offset is FALSE we do not
4358      need to subtract out the offset of the location within the
4359      section (which is just ADDRESS).  */
4360   if (howto->pc_relative)
4361     {
4362       relocation -= (input_section->output_section->vma
4363                      + input_section->output_offset);
4364       if (howto->pcrel_offset)
4365         relocation -= address;
4366     }
4367
4368   return nds32_relocate_contents (howto, input_bfd, relocation,
4369                                   contents + address);
4370 }
4371
4372 static bfd_boolean
4373 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4374                               const char *name,
4375                               Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4376                               asection *input_sec,
4377                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4378 {
4379   const char *source;
4380   FILE *sym_ld_script = NULL;
4381   struct elf_nds32_link_hash_table *table;
4382
4383   table = nds32_elf_hash_table (info);
4384   sym_ld_script = table->sym_ld_script;
4385   if (!sym_ld_script)
4386     return TRUE;
4387
4388   if (!h || !name || *name == '\0')
4389     return TRUE;
4390
4391   if (input_sec->flags & SEC_EXCLUDE)
4392     return TRUE;
4393
4394   if (!check_start_export_sym)
4395     {
4396       fprintf (sym_ld_script, "SECTIONS\n{\n");
4397       check_start_export_sym = 1;
4398     }
4399
4400   if (h->root.type == bfd_link_hash_defined
4401       || h->root.type == bfd_link_hash_defweak)
4402     {
4403       if (!h->root.u.def.section->output_section)
4404         return TRUE;
4405
4406       if (bfd_is_const_section (input_sec))
4407         source = input_sec->name;
4408       else
4409         source = input_sec->owner->filename;
4410
4411       fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4412                h->root.root.string,
4413                (long) (h->root.u.def.value
4414                 + h->root.u.def.section->output_section->vma
4415                 + h->root.u.def.section->output_offset), source);
4416     }
4417
4418   return TRUE;
4419 }
4420
4421 /* Relocate an NDS32/D ELF section.
4422    There is some attempt to make this function usable for many architectures,
4423    both for RELA and REL type relocs, if only to serve as a learning tool.
4424
4425    The RELOCATE_SECTION function is called by the new ELF backend linker
4426    to handle the relocations for a section.
4427
4428    The relocs are always passed as Rela structures; if the section
4429    actually uses Rel structures, the r_addend field will always be
4430    zero.
4431
4432    This function is responsible for adjust the section contents as
4433    necessary, and (if using Rela relocs and generating a
4434    relocatable output file) adjusting the reloc addend as
4435    necessary.
4436
4437    This function does not have to worry about setting the reloc
4438    address or the reloc symbol index.
4439
4440    LOCAL_SYMS is a pointer to the swapped in local symbols.
4441
4442    LOCAL_SECTIONS is an array giving the section in the input file
4443    corresponding to the st_shndx field of each local symbol.
4444
4445    The global hash table entry for the global symbols can be found
4446    via elf_sym_hashes (input_bfd).
4447
4448    When generating relocatable output, this function must handle
4449    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
4450    going to be the section symbol corresponding to the output
4451    section, which means that the addend must be adjusted
4452    accordingly.  */
4453
4454 static bfd_vma
4455 dtpoff_base (struct bfd_link_info *info)
4456 {
4457   /* If tls_sec is NULL, we should have signalled an error already.  */
4458   if (elf_hash_table (info)->tls_sec == NULL)
4459     return 0;
4460   return elf_hash_table (info)->tls_sec->vma;
4461 }
4462
4463 static bfd_boolean
4464 nds32_elf_relocate_section (bfd *                  output_bfd ATTRIBUTE_UNUSED,
4465                             struct bfd_link_info * info,
4466                             bfd *                  input_bfd,
4467                             asection *             input_section,
4468                             bfd_byte *             contents,
4469                             Elf_Internal_Rela *    relocs,
4470                             Elf_Internal_Sym *     local_syms,
4471                             asection **            local_sections)
4472 {
4473   Elf_Internal_Shdr *symtab_hdr;
4474   struct elf_link_hash_entry **sym_hashes;
4475   Elf_Internal_Rela *rel, *relend;
4476   bfd_boolean ret = TRUE;               /* Assume success.  */
4477   int align = 0;
4478   bfd_reloc_status_type r;
4479   const char *errmsg = NULL;
4480   bfd_vma gp;
4481   struct elf_nds32_link_hash_table *htab;
4482   bfd *dynobj;
4483   bfd_vma *local_got_offsets;
4484   asection *sgot, *splt, *sreloc;
4485   bfd_vma high_address;
4486   struct elf_nds32_link_hash_table *table;
4487   int eliminate_gc_relocs;
4488   bfd_vma fpbase_addr;
4489
4490   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4491   sym_hashes = elf_sym_hashes (input_bfd);
4492   htab = nds32_elf_hash_table (info);
4493   high_address = bfd_get_section_limit (input_bfd, input_section);
4494
4495   dynobj = htab->root.dynobj;
4496   local_got_offsets = elf_local_got_offsets (input_bfd);
4497
4498   sgot = htab->sgot;
4499   splt = htab->splt;
4500   sreloc = NULL;
4501
4502   rel = relocs;
4503   relend = relocs + input_section->reloc_count;
4504
4505   table = nds32_elf_hash_table (info);
4506   eliminate_gc_relocs = table->eliminate_gc_relocs;
4507   /* By this time, we can adjust the value of _SDA_BASE_.  */
4508   if ((!info->relocatable))
4509     {
4510       is_SDA_BASE_set = 1;
4511       r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4512       if (r != bfd_reloc_ok)
4513         return FALSE;
4514     }
4515
4516   if (is_ITB_BASE_set == 0)
4517     {
4518       /* Set the _ITB_BASE_.  */
4519       if (!nds32_elf_ex9_itb_base (info))
4520         {
4521           (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"),
4522                                  output_bfd);
4523           bfd_set_error (bfd_error_bad_value);
4524         }
4525     }
4526
4527   if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4528     if (!nds32_elf_ifc_reloc ())
4529       (*_bfd_error_handler) (_("error: IFC relocation error."));
4530
4531  /* Relocation for .ex9.itable.  */
4532   if (table->target_optimize & NDS32_RELAX_EX9_ON
4533       || (table->ex9_import_file && table->update_ex9_table))
4534     nds32_elf_ex9_reloc_jmp (info);
4535
4536   /* Use gp as fp to prevent truncated fit.  Because in relaxation time
4537      the fp value is set as gp, and it has be reverted for instruction
4538      setting fp.  */
4539   fpbase_addr = elf_gp (output_bfd);
4540
4541   for (rel = relocs; rel < relend; rel++)
4542     {
4543       enum elf_nds32_reloc_type r_type;
4544       reloc_howto_type *howto = NULL;
4545       unsigned long r_symndx;
4546       struct elf_link_hash_entry *h = NULL;
4547       Elf_Internal_Sym *sym = NULL;
4548       asection *sec;
4549       bfd_vma relocation;
4550
4551       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4552          ensure it's zero (we use REL relocs, not RELA).  Therefore this
4553          should be assigning zero to `addend', but for clarity we use
4554          `r_addend'.  */
4555
4556       bfd_vma addend = rel->r_addend;
4557       bfd_vma offset = rel->r_offset;
4558
4559       r_type = ELF32_R_TYPE (rel->r_info);
4560       if (r_type >= R_NDS32_max)
4561         {
4562           (*_bfd_error_handler) (_("%B: error: unknown relocation type %d."),
4563                                  input_bfd, r_type);
4564           bfd_set_error (bfd_error_bad_value);
4565           ret = FALSE;
4566           continue;
4567         }
4568
4569       if (r_type == R_NDS32_GNU_VTENTRY
4570           || r_type == R_NDS32_GNU_VTINHERIT
4571           || r_type == R_NDS32_NONE
4572           || r_type == R_NDS32_RELA_GNU_VTENTRY
4573           || r_type == R_NDS32_RELA_GNU_VTINHERIT
4574           || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4575           || r_type == R_NDS32_DATA
4576           || r_type == R_NDS32_TRAN
4577           || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP7))
4578         continue;
4579
4580       /* If we enter the fp-as-gp region.  Resolve the address
4581          of best fp-base.  */
4582       if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4583           && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4584         {
4585           int dist;
4586
4587           /* Distance to relocation of best fp-base is encoded in R_SYM.  */
4588           dist =  rel->r_addend >> 16;
4589           fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4590                                                   local_syms, symtab_hdr);
4591         }
4592       else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4593                && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4594         {
4595           fpbase_addr = elf_gp (output_bfd);
4596         }
4597
4598       if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4599             && r_type <= R_NDS32_DWARF2_LEB_RELA)
4600            || r_type >= R_NDS32_RELAX_ENTRY) && !info->relocatable)
4601         continue;
4602
4603       howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4604       r_symndx = ELF32_R_SYM (rel->r_info);
4605
4606       /* This is a final link.  */
4607       sym = NULL;
4608       sec = NULL;
4609       h = NULL;
4610
4611       if (r_symndx < symtab_hdr->sh_info)
4612         {
4613           /* Local symbol.  */
4614           sym = local_syms + r_symndx;
4615           sec = local_sections[r_symndx];
4616
4617           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4618           addend = rel->r_addend;
4619         }
4620       else
4621         {
4622           /* External symbol.  */
4623           bfd_boolean warned, ignored, unresolved_reloc;
4624           int symndx = r_symndx - symtab_hdr->sh_info;
4625
4626           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4627                                    r_symndx, symtab_hdr, sym_hashes, h, sec,
4628                                    relocation, unresolved_reloc, warned,
4629                                    ignored);
4630
4631           /* la $fp, _FP_BASE_ is per-function (region).
4632              Handle it specially.  */
4633           switch ((int) r_type)
4634             {
4635             case R_NDS32_SDA19S0_RELA:
4636             case R_NDS32_SDA15S0_RELA:
4637             case R_NDS32_20_RELA:
4638               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4639                           FP_BASE_NAME) == 0)
4640                 {
4641                   relocation = fpbase_addr;
4642                   break;
4643                 }
4644             }
4645
4646         }
4647
4648       if (info->relocatable)
4649         {
4650           /* This is a relocatable link.  We don't have to change
4651              anything, unless the reloc is against a section symbol,
4652              in which case we have to adjust according to where the
4653              section symbol winds up in the output section.  */
4654           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4655             rel->r_addend += sec->output_offset + sym->st_value;
4656
4657           continue;
4658         }
4659
4660       /* Sanity check the address.  */
4661       if (offset > high_address)
4662         {
4663           r = bfd_reloc_outofrange;
4664           goto check_reloc;
4665         }
4666
4667       if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4668            && r_type <= R_NDS32_DWARF2_LEB_RELA)
4669           || r_type >= R_NDS32_RELAX_ENTRY)
4670         continue;
4671
4672       switch ((int) r_type)
4673         {
4674         case R_NDS32_GOTOFF:
4675           /* Relocation is relative to the start of the global offset
4676              table (for ld24 rx, #uimm24), e.g. access at label+addend
4677
4678              ld24 rx. #label@GOTOFF + addend
4679              sub  rx, r12.  */
4680         case R_NDS32_GOTOFF_HI20:
4681         case R_NDS32_GOTOFF_LO12:
4682         case R_NDS32_GOTOFF_LO15:
4683         case R_NDS32_GOTOFF_LO19:
4684           BFD_ASSERT (sgot != NULL);
4685
4686           relocation -= elf_gp (output_bfd);
4687           break;
4688
4689         case R_NDS32_9_PLTREL:
4690         case R_NDS32_25_PLTREL:
4691           /* Relocation is to the entry for this symbol in the
4692              procedure linkage table.  */
4693
4694           /* The native assembler will generate a 25_PLTREL reloc
4695              for a local symbol if you assemble a call from one
4696              section to another when using -K pic.  */
4697           if (h == NULL)
4698             break;
4699
4700           if (h->forced_local)
4701             break;
4702
4703           /* We didn't make a PLT entry for this symbol.  This
4704              happens when statically linking PIC code, or when
4705              using -Bsymbolic.  */
4706           if (h->plt.offset == (bfd_vma) - 1)
4707             break;
4708
4709           relocation = (splt->output_section->vma
4710                         + splt->output_offset + h->plt.offset);
4711           break;
4712
4713         case R_NDS32_PLT_GOTREL_HI20:
4714         case R_NDS32_PLT_GOTREL_LO12:
4715         case R_NDS32_PLT_GOTREL_LO15:
4716         case R_NDS32_PLT_GOTREL_LO19:
4717         case R_NDS32_PLT_GOTREL_LO20:
4718           if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4719             {
4720               /* We didn't make a PLT entry for this symbol.  This
4721                  happens when statically linking PIC code, or when
4722                  using -Bsymbolic.  */
4723               relocation -= elf_gp (output_bfd);
4724               break;
4725             }
4726
4727           relocation = (splt->output_section->vma
4728                         + splt->output_offset + h->plt.offset);
4729
4730           relocation -= elf_gp (output_bfd);
4731           break;
4732
4733         case R_NDS32_PLTREL_HI20:
4734         case R_NDS32_PLTREL_LO12:
4735
4736           /* Relocation is to the entry for this symbol in the
4737              procedure linkage table.  */
4738
4739           /* The native assembler will generate a 25_PLTREL reloc
4740              for a local symbol if you assemble a call from one
4741              section to another when using -K pic.  */
4742           if (h == NULL)
4743             break;
4744
4745           if (h->forced_local)
4746             break;
4747
4748           if (h->plt.offset == (bfd_vma) - 1)
4749             /* We didn't make a PLT entry for this symbol.  This
4750                happens when statically linking PIC code, or when
4751                using -Bsymbolic.  */
4752             break;
4753
4754           if (splt == NULL)
4755             break;
4756
4757           relocation = (splt->output_section->vma
4758                         + splt->output_offset
4759                         + h->plt.offset + 4)
4760                        - (input_section->output_section->vma
4761                           + input_section->output_offset
4762                           + rel->r_offset);
4763
4764           break;
4765
4766         case R_NDS32_GOTPC20:
4767           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4768              ld24 rx,#_GLOBAL_OFFSET_TABLE_  */
4769           relocation = elf_gp (output_bfd);
4770           break;
4771
4772         case R_NDS32_GOTPC_HI20:
4773         case R_NDS32_GOTPC_LO12:
4774             {
4775               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4776                  bl .+4
4777                  seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4778                  or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4779                  or
4780                  bl .+4
4781                  seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4782                  add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4783                */
4784               relocation = elf_gp (output_bfd);
4785               relocation -= (input_section->output_section->vma
4786                              + input_section->output_offset + rel->r_offset);
4787               break;
4788             }
4789
4790         case R_NDS32_GOT20:
4791           /* Fall through.  */
4792         case R_NDS32_GOT_HI20:
4793         case R_NDS32_GOT_LO12:
4794         case R_NDS32_GOT_LO15:
4795         case R_NDS32_GOT_LO19:
4796           /* Relocation is to the entry for this symbol in the global
4797              offset table.  */
4798           BFD_ASSERT (sgot != NULL);
4799
4800           if (h != NULL)
4801             {
4802               bfd_boolean dyn;
4803               bfd_vma off;
4804
4805               off = h->got.offset;
4806               BFD_ASSERT (off != (bfd_vma) - 1);
4807               dyn = htab->root.dynamic_sections_created;
4808               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4809                   || (info->shared
4810                       && (info->symbolic
4811                           || h->dynindx == -1
4812                           || h->forced_local) && h->def_regular))
4813                 {
4814                   /* This is actually a static link, or it is a
4815                      -Bsymbolic link and the symbol is defined
4816                      locally, or the symbol was forced to be local
4817                      because of a version file.  We must initialize
4818                      this entry in the global offset table.  Since the
4819                      offset must always be a multiple of 4, we use the
4820                      least significant bit to record whether we have
4821                      initialized it already.
4822
4823                      When doing a dynamic link, we create a .rela.got
4824                      relocation entry to initialize the value.  This
4825                      is done in the finish_dynamic_symbol routine.  */
4826                   if ((off & 1) != 0)
4827                     off &= ~1;
4828                   else
4829                     {
4830                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4831                       h->got.offset |= 1;
4832                     }
4833                 }
4834               relocation = sgot->output_section->vma + sgot->output_offset + off
4835                            - elf_gp (output_bfd);
4836             }
4837           else
4838             {
4839               bfd_vma off;
4840               bfd_byte *loc;
4841
4842               BFD_ASSERT (local_got_offsets != NULL
4843                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4844
4845               off = local_got_offsets[r_symndx];
4846
4847               /* The offset must always be a multiple of 4.  We use
4848                  the least significant bit to record whether we have
4849                  already processed this entry.  */
4850               if ((off & 1) != 0)
4851                 off &= ~1;
4852               else
4853                 {
4854                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4855
4856                   if (info->shared)
4857                     {
4858                       asection *srelgot;
4859                       Elf_Internal_Rela outrel;
4860
4861                       /* We need to generate a R_NDS32_RELATIVE reloc
4862                          for the dynamic linker.  */
4863                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4864                       BFD_ASSERT (srelgot != NULL);
4865
4866                       outrel.r_offset = (elf_gp (output_bfd)
4867                                          + sgot->output_offset + off);
4868                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4869                       outrel.r_addend = relocation;
4870                       loc = srelgot->contents;
4871                       loc +=
4872                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
4873                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4874                       ++srelgot->reloc_count;
4875                     }
4876                   local_got_offsets[r_symndx] |= 1;
4877                 }
4878               relocation = sgot->output_section->vma + sgot->output_offset + off
4879                            - elf_gp (output_bfd);
4880             }
4881
4882           break;
4883
4884         case R_NDS32_16_RELA:
4885         case R_NDS32_20_RELA:
4886         case R_NDS32_5_RELA:
4887         case R_NDS32_32_RELA:
4888         case R_NDS32_9_PCREL_RELA:
4889         case R_NDS32_WORD_9_PCREL_RELA:
4890         case R_NDS32_10_UPCREL_RELA:
4891         case R_NDS32_15_PCREL_RELA:
4892         case R_NDS32_17_PCREL_RELA:
4893         case R_NDS32_25_PCREL_RELA:
4894         case R_NDS32_HI20_RELA:
4895         case R_NDS32_LO12S3_RELA:
4896         case R_NDS32_LO12S2_RELA:
4897         case R_NDS32_LO12S2_DP_RELA:
4898         case R_NDS32_LO12S2_SP_RELA:
4899         case R_NDS32_LO12S1_RELA:
4900         case R_NDS32_LO12S0_RELA:
4901         case R_NDS32_LO12S0_ORI_RELA:
4902           if (info->shared && r_symndx != 0
4903               && (input_section->flags & SEC_ALLOC) != 0
4904               && (eliminate_gc_relocs == 0
4905                   || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4906               && ((r_type != R_NDS32_9_PCREL_RELA
4907                    && r_type != R_NDS32_WORD_9_PCREL_RELA
4908                    && r_type != R_NDS32_10_UPCREL_RELA
4909                    && r_type != R_NDS32_15_PCREL_RELA
4910                    && r_type != R_NDS32_17_PCREL_RELA
4911                    && r_type != R_NDS32_25_PCREL_RELA
4912                    && !(r_type == R_NDS32_32_RELA
4913                         && strcmp (input_section->name, ".eh_frame") == 0))
4914                   || (h != NULL && h->dynindx != -1
4915                       && (!info->symbolic || !h->def_regular))))
4916             {
4917               Elf_Internal_Rela outrel;
4918               bfd_boolean skip, relocate;
4919               bfd_byte *loc;
4920
4921               /* When generating a shared object, these relocations
4922                  are copied into the output file to be resolved at run
4923                  time.  */
4924
4925               if (sreloc == NULL)
4926                 {
4927                   const char *name;
4928
4929                   name = bfd_elf_string_from_elf_section
4930                     (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4931                      elf_section_data (input_section)->rela.hdr->sh_name);
4932                   if (name == NULL)
4933                     return FALSE;
4934
4935                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4936                               && strcmp (bfd_get_section_name (input_bfd,
4937                                                                input_section),
4938                                          name + 5) == 0);
4939
4940                   sreloc = bfd_get_section_by_name (dynobj, name);
4941                   BFD_ASSERT (sreloc != NULL);
4942                 }
4943
4944               skip = FALSE;
4945               relocate = FALSE;
4946
4947               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4948                                                          info,
4949                                                          input_section,
4950                                                          rel->r_offset);
4951               if (outrel.r_offset == (bfd_vma) - 1)
4952                 skip = TRUE;
4953               else if (outrel.r_offset == (bfd_vma) - 2)
4954                 skip = TRUE, relocate = TRUE;
4955               outrel.r_offset += (input_section->output_section->vma
4956                                   + input_section->output_offset);
4957
4958               if (skip)
4959                 memset (&outrel, 0, sizeof outrel);
4960               else if (r_type == R_NDS32_17_PCREL_RELA
4961                        || r_type == R_NDS32_15_PCREL_RELA
4962                        || r_type == R_NDS32_25_PCREL_RELA)
4963                 {
4964                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4965                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4966                   outrel.r_addend = rel->r_addend;
4967                 }
4968               else
4969                 {
4970                   /* h->dynindx may be -1 if this symbol was marked to
4971                      become local.  */
4972                   if (h == NULL
4973                       || ((info->symbolic || h->dynindx == -1)
4974                           && h->def_regular))
4975                     {
4976                       relocate = TRUE;
4977                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4978                       outrel.r_addend = relocation + rel->r_addend;
4979                     }
4980                   else
4981                     {
4982                       BFD_ASSERT (h->dynindx != -1);
4983                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4984                       outrel.r_addend = rel->r_addend;
4985                     }
4986                 }
4987
4988               loc = sreloc->contents;
4989               loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4990               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4991               ++sreloc->reloc_count;
4992
4993               /* If this reloc is against an external symbol, we do
4994                  not want to fiddle with the addend.  Otherwise, we
4995                  need to include the symbol value so that it becomes
4996                  an addend for the dynamic reloc.  */
4997               if (!relocate)
4998                 continue;
4999             }
5000           break;
5001
5002         case R_NDS32_25_ABS_RELA:
5003           if (info->shared)
5004             {
5005               (*_bfd_error_handler)
5006                 (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
5007                    "mode."), bfd_get_filename (input_bfd));
5008               return FALSE;
5009             }
5010           break;
5011
5012         case R_NDS32_9_PCREL:
5013           r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5014                                           contents, offset,
5015                                           sec, relocation, addend);
5016           goto check_reloc;
5017
5018         case R_NDS32_HI20:
5019             {
5020               Elf_Internal_Rela *lorel;
5021
5022               /* We allow an arbitrary number of HI20 relocs before the
5023                  LO12 reloc.  This permits gcc to emit the HI and LO relocs
5024                  itself.  */
5025               for (lorel = rel + 1;
5026                    (lorel < relend
5027                     && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5028                 continue;
5029               if (lorel < relend
5030                   && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5031                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5032                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5033                       || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5034                 {
5035                   nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5036                                            contents, relocation + addend);
5037                   r = bfd_reloc_ok;
5038                 }
5039               else
5040                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5041                                               contents, offset, relocation,
5042                                               addend);
5043             }
5044
5045           goto check_reloc;
5046
5047         case R_NDS32_GOT17S2_RELA:
5048         case R_NDS32_GOT15S2_RELA:
5049             {
5050               bfd_vma off;
5051
5052               BFD_ASSERT (sgot != NULL);
5053
5054               if (h != NULL)
5055                 {
5056                   bfd_boolean dyn;
5057
5058                   off = h->got.offset;
5059                   BFD_ASSERT (off != (bfd_vma) - 1);
5060
5061                   dyn = htab->root.dynamic_sections_created;
5062                   if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5063                       (dyn, info->shared, h) || (info->shared
5064                                                  && (info->symbolic
5065                                                      || h->dynindx == -1
5066                                                      || h->forced_local)
5067                                                  && h->def_regular))
5068                     {
5069                       /* This is actually a static link, or it is a
5070                          -Bsymbolic link and the symbol is defined
5071                          locally, or the symbol was forced to be local
5072                          because of a version file.  We must initialize
5073                          this entry in the global offset table.  Since the
5074                          offset must always be a multiple of 4, we use the
5075                          least significant bit to record whether we have
5076                          initialized it already.
5077
5078                          When doing a dynamic link, we create a .rela.got
5079                          relocation entry to initialize the value.  This
5080                          is done in the finish_dynamic_symbol routine.  */
5081                       if ((off & 1) != 0)
5082                         off &= ~1;
5083                       else
5084                         {
5085                           bfd_put_32 (output_bfd, relocation,
5086                                       sgot->contents + off);
5087                           h->got.offset |= 1;
5088                         }
5089                     }
5090                 }
5091               else
5092                 {
5093                   bfd_byte *loc;
5094
5095                   BFD_ASSERT (local_got_offsets != NULL
5096                               && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5097
5098                   off = local_got_offsets[r_symndx];
5099
5100                   /* The offset must always be a multiple of 4.  We use
5101                      the least significant bit to record whether we have
5102                      already processed this entry.  */
5103                   if ((off & 1) != 0)
5104                     off &= ~1;
5105                   else
5106                     {
5107                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5108
5109                       if (info->shared)
5110                         {
5111                           asection *srelgot;
5112                           Elf_Internal_Rela outrel;
5113
5114                           /* We need to generate a R_NDS32_RELATIVE reloc
5115                              for the dynamic linker.  */
5116                           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5117                           BFD_ASSERT (srelgot != NULL);
5118
5119                           outrel.r_offset = (elf_gp (output_bfd)
5120                                              + sgot->output_offset + off);
5121                           outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5122                           outrel.r_addend = relocation;
5123                           loc = srelgot->contents;
5124                           loc +=
5125                             srelgot->reloc_count * sizeof (Elf32_External_Rela);
5126                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5127                           ++srelgot->reloc_count;
5128                         }
5129                       local_got_offsets[r_symndx] |= 1;
5130                     }
5131                 }
5132               relocation = sgot->output_section->vma + sgot->output_offset + off
5133                            - elf_gp (output_bfd);
5134             }
5135           if (relocation & align)
5136             {
5137               /* Incorrect alignment.  */
5138               (*_bfd_error_handler)
5139                 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5140               ret = FALSE;
5141               r = bfd_reloc_dangerous;
5142               goto check_reloc;
5143             }
5144           break;
5145
5146         case R_NDS32_SDA16S3_RELA:
5147         case R_NDS32_SDA15S3_RELA:
5148         case R_NDS32_SDA15S3:
5149           align = 0x7;
5150           goto handle_sda;
5151
5152         case R_NDS32_SDA17S2_RELA:
5153         case R_NDS32_SDA15S2_RELA:
5154         case R_NDS32_SDA12S2_SP_RELA:
5155         case R_NDS32_SDA12S2_DP_RELA:
5156         case R_NDS32_SDA15S2:
5157         case R_NDS32_SDA_FP7U2_RELA:
5158           align = 0x3;
5159           goto handle_sda;
5160
5161         case R_NDS32_SDA18S1_RELA:
5162         case R_NDS32_SDA15S1_RELA:
5163         case R_NDS32_SDA15S1:
5164           align = 0x1;
5165           goto handle_sda;
5166
5167         case R_NDS32_SDA19S0_RELA:
5168         case R_NDS32_SDA15S0_RELA:
5169         case R_NDS32_SDA15S0:
5170             {
5171               align = 0x0;
5172 handle_sda:
5173               BFD_ASSERT (sec != NULL);
5174
5175               /* If the symbol is in the abs section, the out_bfd will be null.
5176                  This happens when the relocation has a symbol@GOTOFF.  */
5177               r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5178               if (r != bfd_reloc_ok)
5179                 {
5180                   (*_bfd_error_handler)
5181                     (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5182                   ret = FALSE;
5183                   goto check_reloc;
5184                 }
5185
5186               /* At this point `relocation' contains the object's
5187                  address.  */
5188               if (r_type == R_NDS32_SDA_FP7U2_RELA)
5189                 {
5190                   relocation -= fpbase_addr;
5191                 }
5192               else
5193                 relocation -= gp;
5194               /* Now it contains the offset from _SDA_BASE_.  */
5195
5196               /* Make sure alignment is correct.  */
5197
5198               if (relocation & align)
5199                 {
5200                   /* Incorrect alignment.  */
5201                   (*_bfd_error_handler)
5202                     (_("%B(%A): warning: unaligned small data access of type %d."),
5203                      input_bfd, input_section, r_type);
5204                   ret = FALSE;
5205                   goto check_reloc;
5206                 }
5207             }
5208
5209           break;
5210         case R_NDS32_17IFC_PCREL_RELA:
5211         case R_NDS32_10IFCU_PCREL_RELA:
5212           /* do nothing */
5213           break;
5214
5215         case R_NDS32_TLS_LE_HI20:
5216         case R_NDS32_TLS_LE_LO12:
5217         case R_NDS32_TLS_LE_20:
5218         case R_NDS32_TLS_LE_15S0:
5219         case R_NDS32_TLS_LE_15S1:
5220         case R_NDS32_TLS_LE_15S2:
5221           if (elf_hash_table (info)->tls_sec != NULL)
5222             relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5223           break;
5224         case R_NDS32_TLS_IE_HI20:
5225         case R_NDS32_TLS_IE_LO12S2:
5226           {
5227             /* Relocation is to the entry for this symbol in the global
5228                offset table.  */
5229             unsigned int tls_type;
5230             asection *srelgot;
5231             Elf_Internal_Rela outrel;
5232             bfd_vma off;
5233             bfd_byte *loc;
5234             int indx = 0;
5235
5236             BFD_ASSERT (sgot != NULL);
5237             if (h != NULL)
5238               {
5239                 bfd_boolean dyn;
5240
5241                 off = h->got.offset;
5242                 BFD_ASSERT (off != (bfd_vma) - 1);
5243                 dyn = htab->root.dynamic_sections_created;
5244                 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5245                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5246                     && (!info->shared
5247                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
5248                   indx = h->dynindx;
5249               }
5250             else
5251               {
5252                 /* Never happen currently.  */
5253                 BFD_ASSERT (local_got_offsets != NULL
5254                             && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5255
5256                 off = local_got_offsets[r_symndx];
5257
5258                 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5259               }
5260             relocation = sgot->output_section->vma + sgot->output_offset + off;
5261
5262             if (r_type == R_NDS32_TLS_IE_LO12S2)
5263               break;
5264
5265             /* The offset must always be a multiple of 4.  We use
5266                the least significant bit to record whether we have
5267                already processed this entry.  */
5268             if ((off & 1) != 0)
5269               off &= ~1;
5270             else
5271               {
5272                 bfd_boolean need_relocs = FALSE;
5273                 srelgot = htab->srelgot;
5274                 if ((info->shared || indx != 0)
5275                     && (h == NULL
5276                         || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5277                         || h->root.type != bfd_link_hash_undefweak))
5278                   {
5279                     need_relocs = TRUE;
5280                     BFD_ASSERT (srelgot != NULL);
5281                   }
5282                 if (tls_type & GOT_TLS_IE)
5283                   {
5284                     if (need_relocs)
5285                       {
5286                         if (h->dynindx == 0)
5287                           outrel.r_addend = relocation - dtpoff_base (info);
5288                         else
5289                           outrel.r_addend = 0;
5290                         outrel.r_offset = (sgot->output_section->vma
5291                                            + sgot->output_offset
5292                                            + off);
5293                         outrel.r_info =
5294                           ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5295
5296                         loc = srelgot->contents;
5297                         loc +=
5298                           srelgot->reloc_count * sizeof (Elf32_External_Rela);
5299                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5300                         ++srelgot->reloc_count;
5301                       }
5302                     else
5303                       bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5304                                   sgot->contents + off);
5305                   }
5306               }
5307           }
5308         break;
5309
5310           /* DON'T   fall through.  */
5311
5312         default:
5313           /* OLD_NDS32_RELOC.  */
5314
5315           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5316                                         contents, offset, relocation, addend);
5317           goto check_reloc;
5318         }
5319
5320       switch ((int) r_type)
5321         {
5322         case R_NDS32_20_RELA:
5323         case R_NDS32_5_RELA:
5324         case R_NDS32_9_PCREL_RELA:
5325         case R_NDS32_WORD_9_PCREL_RELA:
5326         case R_NDS32_10_UPCREL_RELA:
5327         case R_NDS32_15_PCREL_RELA:
5328         case R_NDS32_17_PCREL_RELA:
5329         case R_NDS32_25_PCREL_RELA:
5330         case R_NDS32_25_ABS_RELA:
5331         case R_NDS32_HI20_RELA:
5332         case R_NDS32_LO12S3_RELA:
5333         case R_NDS32_LO12S2_RELA:
5334         case R_NDS32_LO12S2_DP_RELA:
5335         case R_NDS32_LO12S2_SP_RELA:
5336         case R_NDS32_LO12S1_RELA:
5337         case R_NDS32_LO12S0_RELA:
5338         case R_NDS32_LO12S0_ORI_RELA:
5339         case R_NDS32_SDA16S3_RELA:
5340         case R_NDS32_SDA17S2_RELA:
5341         case R_NDS32_SDA18S1_RELA:
5342         case R_NDS32_SDA19S0_RELA:
5343         case R_NDS32_SDA15S3_RELA:
5344         case R_NDS32_SDA15S2_RELA:
5345         case R_NDS32_SDA12S2_DP_RELA:
5346         case R_NDS32_SDA12S2_SP_RELA:
5347         case R_NDS32_SDA15S1_RELA:
5348         case R_NDS32_SDA15S0_RELA:
5349         case R_NDS32_SDA_FP7U2_RELA:
5350         case R_NDS32_9_PLTREL:
5351         case R_NDS32_25_PLTREL:
5352         case R_NDS32_GOT20:
5353         case R_NDS32_GOT_HI20:
5354         case R_NDS32_GOT_LO12:
5355         case R_NDS32_GOT_LO15:
5356         case R_NDS32_GOT_LO19:
5357         case R_NDS32_GOT15S2_RELA:
5358         case R_NDS32_GOT17S2_RELA:
5359         case R_NDS32_GOTPC20:
5360         case R_NDS32_GOTPC_HI20:
5361         case R_NDS32_GOTPC_LO12:
5362         case R_NDS32_GOTOFF:
5363         case R_NDS32_GOTOFF_HI20:
5364         case R_NDS32_GOTOFF_LO12:
5365         case R_NDS32_GOTOFF_LO15:
5366         case R_NDS32_GOTOFF_LO19:
5367         case R_NDS32_PLTREL_HI20:
5368         case R_NDS32_PLTREL_LO12:
5369         case R_NDS32_PLT_GOTREL_HI20:
5370         case R_NDS32_PLT_GOTREL_LO12:
5371         case R_NDS32_PLT_GOTREL_LO15:
5372         case R_NDS32_PLT_GOTREL_LO19:
5373         case R_NDS32_PLT_GOTREL_LO20:
5374         case R_NDS32_17IFC_PCREL_RELA:
5375         case R_NDS32_10IFCU_PCREL_RELA:
5376         case R_NDS32_TLS_LE_HI20:
5377         case R_NDS32_TLS_LE_LO12:
5378         case R_NDS32_TLS_IE_HI20:
5379         case R_NDS32_TLS_IE_LO12S2:
5380         case R_NDS32_TLS_LE_20:
5381         case R_NDS32_TLS_LE_15S0:
5382         case R_NDS32_TLS_LE_15S1:
5383         case R_NDS32_TLS_LE_15S2:
5384           /* Instruction related relocs must handle endian properly.  */
5385           /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER.  */
5386           r = nds32_elf_final_link_relocate (howto, input_bfd,
5387                                              input_section, contents,
5388                                              rel->r_offset, relocation,
5389                                              rel->r_addend);
5390           break;
5391
5392         default:
5393           /* All other relocs can use default handler.  */
5394           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5395                                         contents, rel->r_offset,
5396                                         relocation, rel->r_addend);
5397           break;
5398         }
5399
5400 check_reloc:
5401
5402       if (r != bfd_reloc_ok)
5403         {
5404           /* FIXME: This should be generic enough to go in a utility.  */
5405           const char *name;
5406
5407           if (h != NULL)
5408             name = h->root.root.string;
5409           else
5410             {
5411               name = bfd_elf_string_from_elf_section
5412                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
5413               if (name == NULL || *name == '\0')
5414                 name = bfd_section_name (input_bfd, sec);
5415             }
5416
5417           if (errmsg != NULL)
5418             goto common_error;
5419
5420           switch (r)
5421             {
5422             case bfd_reloc_overflow:
5423               if (!((*info->callbacks->reloc_overflow)
5424                     (info, (h ? &h->root : NULL), name, howto->name,
5425                      (bfd_vma) 0, input_bfd, input_section, offset)))
5426                 return FALSE;
5427               break;
5428
5429             case bfd_reloc_undefined:
5430               if (!((*info->callbacks->undefined_symbol)
5431                     (info, name, input_bfd, input_section, offset, TRUE)))
5432                 return FALSE;
5433               break;
5434
5435             case bfd_reloc_outofrange:
5436               errmsg = _("internal error: out of range error");
5437               goto common_error;
5438
5439             case bfd_reloc_notsupported:
5440               errmsg = _("internal error: unsupported relocation error");
5441               goto common_error;
5442
5443             case bfd_reloc_dangerous:
5444               errmsg = _("internal error: dangerous error");
5445               goto common_error;
5446
5447             default:
5448               errmsg = _("internal error: unknown error");
5449               /* Fall through.  */
5450
5451 common_error:
5452               if (!((*info->callbacks->warning)
5453                     (info, errmsg, name, input_bfd, input_section, offset)))
5454                 return FALSE;
5455               break;
5456             }
5457         }
5458     }
5459
5460   return ret;
5461 }
5462
5463 /* Finish up dynamic symbol handling.  We set the contents of various
5464    dynamic sections here.  */
5465
5466 static bfd_boolean
5467 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5468                                  struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5469 {
5470   struct elf_nds32_link_hash_table *htab;
5471   bfd_byte *loc;
5472
5473   htab = nds32_elf_hash_table (info);
5474
5475   if (h->plt.offset != (bfd_vma) - 1)
5476     {
5477       asection *splt;
5478       asection *sgot;
5479       asection *srela;
5480
5481       bfd_vma plt_index;
5482       bfd_vma got_offset;
5483       bfd_vma local_plt_offset;
5484       Elf_Internal_Rela rela;
5485
5486       /* This symbol has an entry in the procedure linkage table.  Set
5487          it up.  */
5488
5489       BFD_ASSERT (h->dynindx != -1);
5490
5491       splt = htab->splt;
5492       sgot = htab->sgotplt;
5493       srela = htab->srelplt;
5494       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5495
5496       /* Get the index in the procedure linkage table which
5497          corresponds to this symbol.  This is the index of this symbol
5498          in all the symbols for which we are making plt entries.  The
5499          first entry in the procedure linkage table is reserved.  */
5500       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5501
5502       /* Get the offset into the .got table of the entry that
5503          corresponds to this function.  Each .got entry is 4 bytes.
5504          The first three are reserved.  */
5505       got_offset = (plt_index + 3) * 4;
5506
5507       /* Fill in the entry in the procedure linkage table.  */
5508       if (!info->shared)
5509         {
5510           unsigned long insn;
5511
5512           insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5513                                       + sgot->output_offset + got_offset) >> 12)
5514                                     & 0xfffff);
5515           bfd_putb32 (insn, splt->contents + h->plt.offset);
5516
5517           insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5518                                       + sgot->output_offset + got_offset) & 0x0fff)
5519                                     >> 2);
5520           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5521
5522           insn = PLT_ENTRY_WORD2;
5523           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5524
5525           insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5526           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5527
5528           insn = PLT_ENTRY_WORD4
5529                  + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5530           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5531           local_plt_offset = 12;
5532         }
5533       else
5534         {
5535           /* sda_base must be set at this time.  */
5536           unsigned long insn;
5537           long offset;
5538
5539           /* FIXME, sda_base is 65536, it will damage opcode.  */
5540           /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5541           offset = sgot->output_section->vma + sgot->output_offset + got_offset
5542                    - elf_gp (output_bfd);
5543           insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5544           bfd_putb32 (insn, splt->contents + h->plt.offset);
5545
5546           insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5547           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5548
5549           insn = PLT_PIC_ENTRY_WORD2;
5550           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5551
5552           insn = PLT_PIC_ENTRY_WORD3;
5553           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5554
5555           insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5556           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5557
5558           insn = PLT_PIC_ENTRY_WORD5
5559             + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5560           bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5561
5562           local_plt_offset = 16;
5563         }
5564
5565       /* Fill in the entry in the global offset table,
5566          so it will fall through to the next instruction for the first time.  */
5567       bfd_put_32 (output_bfd,
5568                   (splt->output_section->vma + splt->output_offset
5569                    + h->plt.offset + local_plt_offset),
5570                   sgot->contents + got_offset);
5571
5572       /* Fill in the entry in the .rela.plt section.  */
5573       rela.r_offset = (sgot->output_section->vma
5574                        + sgot->output_offset + got_offset);
5575       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5576       rela.r_addend = 0;
5577       loc = srela->contents;
5578       loc += plt_index * sizeof (Elf32_External_Rela);
5579       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5580
5581       if (!h->def_regular)
5582         {
5583           /* Mark the symbol as undefined, rather than as defined in
5584              the .plt section.  Leave the value alone.  */
5585           sym->st_shndx = SHN_UNDEF;
5586           if (!h->ref_regular_nonweak)
5587             sym->st_value = 0;
5588         }
5589     }
5590
5591   if (h->got.offset != (bfd_vma) - 1)
5592     {
5593       asection *sgot;
5594       asection *srela;
5595       Elf_Internal_Rela rela;
5596
5597       /* This symbol has an entry in the global offset table.
5598          Set it up.  */
5599
5600       sgot = htab->sgot;
5601       srela = htab->srelgot;
5602       BFD_ASSERT (sgot != NULL && srela != NULL);
5603
5604       rela.r_offset = (sgot->output_section->vma
5605                        + sgot->output_offset + (h->got.offset & ~1));
5606
5607       /* If this is a -Bsymbolic link, and the symbol is defined
5608          locally, we just want to emit a RELATIVE reloc.  Likewise if
5609          the symbol was forced to be local because of a version file.
5610          The entry in the global offset table will already have been
5611          initialized in the relocate_section function.  */
5612       if (info->shared
5613           && (info->symbolic
5614               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5615         {
5616           rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5617           rela.r_addend = (h->root.u.def.value
5618                            + h->root.u.def.section->output_section->vma
5619                            + h->root.u.def.section->output_offset);
5620         }
5621       else
5622         {
5623           BFD_ASSERT ((h->got.offset & 1) == 0);
5624           bfd_put_32 (output_bfd, (bfd_vma) 0,
5625                       sgot->contents + h->got.offset);
5626           rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5627           rela.r_addend = 0;
5628         }
5629
5630       loc = srela->contents;
5631       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5632       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5633       ++srela->reloc_count;
5634     }
5635
5636   if (h->needs_copy)
5637     {
5638       asection *s;
5639       Elf_Internal_Rela rela;
5640
5641       /* This symbols needs a copy reloc.  Set it up.  */
5642
5643       BFD_ASSERT (h->dynindx != -1
5644                   && (h->root.type == bfd_link_hash_defined
5645                       || h->root.type == bfd_link_hash_defweak));
5646
5647       s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5648       BFD_ASSERT (s != NULL);
5649
5650       rela.r_offset = (h->root.u.def.value
5651                        + h->root.u.def.section->output_section->vma
5652                        + h->root.u.def.section->output_offset);
5653       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5654       rela.r_addend = 0;
5655       loc = s->contents;
5656       loc += s->reloc_count * sizeof (Elf32_External_Rela);
5657       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5658       ++s->reloc_count;
5659     }
5660
5661   /* Mark some specially defined symbols as absolute.  */
5662   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5663       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5664     sym->st_shndx = SHN_ABS;
5665
5666   return TRUE;
5667 }
5668
5669
5670 /* Finish up the dynamic sections.  */
5671
5672 static bfd_boolean
5673 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5674 {
5675   struct elf_nds32_link_hash_table *htab;
5676   bfd *dynobj;
5677   asection *sdyn;
5678   asection *sgot;
5679
5680   htab = nds32_elf_hash_table (info);
5681   dynobj = htab->root.dynobj;
5682
5683   sgot = htab->sgotplt;
5684   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5685
5686   if (htab->root.dynamic_sections_created)
5687     {
5688       asection *splt;
5689       Elf32_External_Dyn *dyncon, *dynconend;
5690
5691       BFD_ASSERT (sgot != NULL && sdyn != NULL);
5692
5693       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5694       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5695
5696       for (; dyncon < dynconend; dyncon++)
5697         {
5698           Elf_Internal_Dyn dyn;
5699           asection *s;
5700
5701           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5702
5703           switch (dyn.d_tag)
5704             {
5705             default:
5706               break;
5707
5708             case DT_PLTGOT:
5709               /* name = ".got"; */
5710               s = htab->sgot->output_section;
5711               goto get_vma;
5712             case DT_JMPREL:
5713               s = htab->srelplt->output_section;
5714             get_vma:
5715               BFD_ASSERT (s != NULL);
5716               dyn.d_un.d_ptr = s->vma;
5717               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5718               break;
5719
5720             case DT_PLTRELSZ:
5721               s = htab->srelplt->output_section;
5722               BFD_ASSERT (s != NULL);
5723               dyn.d_un.d_val = s->size;
5724               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5725               break;
5726
5727             case DT_RELASZ:
5728               /* My reading of the SVR4 ABI indicates that the
5729                  procedure linkage table relocs (DT_JMPREL) should be
5730                  included in the overall relocs (DT_RELA).  This is
5731                  what Solaris does.  However, UnixWare can not handle
5732                  that case.  Therefore, we override the DT_RELASZ entry
5733                  here to make it not include the JMPREL relocs.  Since
5734                  the linker script arranges for .rela.plt to follow all
5735                  other relocation sections, we don't have to worry
5736                  about changing the DT_RELA entry.  */
5737               if (htab->srelplt != NULL)
5738                 {
5739                   s = htab->srelplt->output_section;
5740                   dyn.d_un.d_val -= s->size;
5741                 }
5742               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5743               break;
5744             }
5745         }
5746
5747       /* Fill in the first entry in the procedure linkage table.  */
5748       splt = htab->splt;
5749       if (splt && splt->size > 0)
5750         {
5751           if (info->shared)
5752             {
5753               unsigned long insn;
5754               long offset;
5755
5756               /* FIXME, sda_base is 65536, it will damage opcode.  */
5757               /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5758               offset = sgot->output_section->vma + sgot->output_offset + 4
5759                        - elf_gp (output_bfd);
5760               insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5761               bfd_putb32 (insn, splt->contents);
5762
5763               /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5764               /* here has a typo?  */
5765               insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5766               bfd_putb32 (insn, splt->contents + 4);
5767
5768               insn = PLT0_PIC_ENTRY_WORD2;
5769               bfd_putb32 (insn, splt->contents + 8);
5770
5771               insn = PLT0_PIC_ENTRY_WORD3;
5772               bfd_putb32 (insn, splt->contents + 12);
5773
5774               insn = PLT0_PIC_ENTRY_WORD4;
5775               bfd_putb32 (insn, splt->contents + 16);
5776
5777               insn = PLT0_PIC_ENTRY_WORD5;
5778               bfd_putb32 (insn, splt->contents + 20);
5779             }
5780           else
5781             {
5782               unsigned long insn;
5783               unsigned long addr;
5784
5785               /* addr = .got + 4 */
5786               addr = sgot->output_section->vma + sgot->output_offset + 4;
5787               insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5788               bfd_putb32 (insn, splt->contents);
5789
5790               insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5791               bfd_putb32 (insn, splt->contents + 4);
5792
5793               insn = PLT0_ENTRY_WORD2;
5794               bfd_putb32 (insn, splt->contents + 8);
5795
5796               insn = PLT0_ENTRY_WORD3;
5797               bfd_putb32 (insn, splt->contents + 12);
5798
5799               insn = PLT0_ENTRY_WORD4;
5800               bfd_putb32 (insn, splt->contents + 16);
5801             }
5802
5803           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5804             PLT_ENTRY_SIZE;
5805         }
5806     }
5807
5808   /* Fill in the first three entries in the global offset table.  */
5809   if (sgot && sgot->size > 0)
5810     {
5811       if (sdyn == NULL)
5812         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5813       else
5814         bfd_put_32 (output_bfd,
5815                     sdyn->output_section->vma + sdyn->output_offset,
5816                     sgot->contents);
5817       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5818       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5819
5820       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5821     }
5822
5823   return TRUE;
5824 }
5825 \f
5826
5827 /* Set the right machine number.  */
5828
5829 static bfd_boolean
5830 nds32_elf_object_p (bfd *abfd)
5831 {
5832   static unsigned int cur_arch = 0;
5833
5834   if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5835     {
5836       /* E_N1_ARCH is a wild card, so it is set only when no others exist.  */
5837       cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5838     }
5839
5840   switch (cur_arch)
5841     {
5842     default:
5843     case E_N1_ARCH:
5844       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5845       break;
5846     case E_N1H_ARCH:
5847       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5848       break;
5849     case E_NDS_ARCH_STAR_V2_0:
5850       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5851       break;
5852     case E_NDS_ARCH_STAR_V3_0:
5853       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5854       break;
5855     case E_NDS_ARCH_STAR_V3_M:
5856       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5857       break;
5858     }
5859
5860   return TRUE;
5861 }
5862
5863 /* Store the machine number in the flags field.  */
5864
5865 static void
5866 nds32_elf_final_write_processing (bfd *abfd,
5867                                   bfd_boolean linker ATTRIBUTE_UNUSED)
5868 {
5869   unsigned long val;
5870   static unsigned int cur_mach = 0;
5871
5872   if (bfd_mach_n1 != bfd_get_mach (abfd))
5873     {
5874       cur_mach = bfd_get_mach (abfd);
5875     }
5876
5877   switch (cur_mach)
5878     {
5879     case bfd_mach_n1:
5880       /* Only happen when object is empty, since the case is abandon.  */
5881       val = E_N1_ARCH;
5882       val |= E_NDS_ABI_AABI;
5883       val |= E_NDS32_ELF_VER_1_4;
5884       break;
5885     case bfd_mach_n1h:
5886       val = E_N1H_ARCH;
5887       break;
5888     case bfd_mach_n1h_v2:
5889       val = E_NDS_ARCH_STAR_V2_0;
5890       break;
5891     case bfd_mach_n1h_v3:
5892       val = E_NDS_ARCH_STAR_V3_0;
5893       break;
5894     case bfd_mach_n1h_v3m:
5895       val = E_NDS_ARCH_STAR_V3_M;
5896       break;
5897     default:
5898       val = 0;
5899       break;
5900     }
5901
5902   elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5903   elf_elfheader (abfd)->e_flags |= val;
5904 }
5905
5906 /* Function to keep NDS32 specific file flags.  */
5907
5908 static bfd_boolean
5909 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5910 {
5911   BFD_ASSERT (!elf_flags_init (abfd)
5912               || elf_elfheader (abfd)->e_flags == flags);
5913
5914   elf_elfheader (abfd)->e_flags = flags;
5915   elf_flags_init (abfd) = TRUE;
5916   return TRUE;
5917 }
5918
5919 static unsigned int
5920 convert_e_flags (unsigned int e_flags, unsigned int arch)
5921 {
5922   if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5923     {
5924       /* From 0.9 to 1.0.  */
5925       e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5926
5927       /* Invert E_NDS32_HAS_NO_MAC_INST.  */
5928       e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5929       if (arch == E_NDS_ARCH_STAR_V1_0)
5930         {
5931           /* Done.  */
5932           return e_flags;
5933         }
5934     }
5935
5936   /* From 1.0 to 2.0.  */
5937   e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5938
5939   /* Clear E_NDS32_HAS_MFUSR_PC_INST.  */
5940   e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5941
5942   /* Invert E_NDS32_HAS_NO_MAC_INST.  */
5943   e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5944   return e_flags;
5945 }
5946
5947 static bfd_boolean
5948 nds32_check_vec_size (bfd *ibfd)
5949 {
5950   static unsigned int nds32_vec_size = 0;
5951
5952   asection *sec_t = NULL;
5953   bfd_byte *contents = NULL;
5954
5955   sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5956
5957   if (sec_t && sec_t->size >= 4)
5958     {
5959       /* Get vec_size in file.  */
5960       unsigned int flag_t;
5961
5962       nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
5963       flag_t = bfd_get_32 (ibfd, contents);
5964
5965       /* The value could only be 4 or 16.  */
5966
5967       if (!nds32_vec_size)
5968         /* Set if not set yet.  */
5969         nds32_vec_size = (flag_t & 0x3);
5970       else if (nds32_vec_size != (flag_t & 0x3))
5971         {
5972           (*_bfd_error_handler) (_("%B: ISR vector size mismatch"
5973                                    " with previous modules, previous %u-byte, current %u-byte"),
5974                                  ibfd,
5975                                  nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5976                                  (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5977           return FALSE;
5978         }
5979       else
5980         /* Only keep the first vec_size section.  */
5981         sec_t->flags |= SEC_EXCLUDE;
5982     }
5983
5984   return TRUE;
5985 }
5986
5987 /* Merge backend specific data from an object file to the output
5988    object file when linking.  */
5989
5990 static bfd_boolean
5991 nds32_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5992 {
5993   flagword out_flags;
5994   flagword in_flags;
5995   flagword out_16regs;
5996   flagword in_no_mac;
5997   flagword out_no_mac;
5998   flagword in_16regs;
5999   flagword out_version;
6000   flagword in_version;
6001   flagword out_fpu_config;
6002   flagword in_fpu_config;
6003
6004   /* TODO: Revise to use object-attributes instead.  */
6005   if (!nds32_check_vec_size (ibfd))
6006     return FALSE;
6007
6008   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6009       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6010     return TRUE;
6011
6012   if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6013     {
6014       (*_bfd_error_handler)
6015         (_("%B: warning: Endian mismatch with previous modules."), ibfd);
6016
6017       bfd_set_error (bfd_error_bad_value);
6018       return FALSE;
6019     }
6020
6021   in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6022   if (in_version == E_NDS32_ELF_VER_1_2)
6023     {
6024       (*_bfd_error_handler)
6025         (_("%B: warning: Older version of object file encountered, "
6026            "Please recompile with current tool chain."), ibfd);
6027     }
6028
6029   /* We may need to merge V1 and V2 arch object files to V2.  */
6030   if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6031       != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6032     {
6033       /* Need to convert version.  */
6034       if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6035           == E_NDS_ARCH_STAR_RESERVED)
6036         {
6037           elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6038         }
6039       else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
6040                || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6041                   > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6042         {
6043           elf_elfheader (obfd)->e_flags =
6044             convert_e_flags (elf_elfheader (obfd)->e_flags,
6045                              (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6046         }
6047       else
6048         {
6049           elf_elfheader (ibfd)->e_flags =
6050             convert_e_flags (elf_elfheader (ibfd)->e_flags,
6051                              (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6052         }
6053     }
6054
6055   /* Extract some flags.  */
6056   in_flags = elf_elfheader (ibfd)->e_flags
6057              & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6058                   | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6059
6060   /* The following flags need special treatment.  */
6061   in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6062   in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6063   in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6064
6065   /* Extract some flags.  */
6066   out_flags = elf_elfheader (obfd)->e_flags
6067               & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6068                    | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6069
6070   /* The following flags need special treatment.  */
6071   out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6072   out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6073   out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6074   out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6075   if (!elf_flags_init (obfd))
6076     {
6077       /* If the input is the default architecture then do not
6078          bother setting the flags for the output architecture,
6079          instead allow future merges to do this.  If no future
6080          merges ever set these flags then they will retain their
6081          unitialised values, which surprise surprise, correspond
6082          to the default values.  */
6083       if (bfd_get_arch_info (ibfd)->the_default)
6084         return TRUE;
6085
6086       elf_flags_init (obfd) = TRUE;
6087       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6088
6089       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6090           && bfd_get_arch_info (obfd)->the_default)
6091         {
6092           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6093                                     bfd_get_mach (ibfd));
6094         }
6095
6096       return TRUE;
6097     }
6098
6099   /* Check flag compatibility.  */
6100   if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6101     {
6102       (*_bfd_error_handler)
6103         (_("%B: error: ABI mismatch with previous modules."), ibfd);
6104
6105       bfd_set_error (bfd_error_bad_value);
6106       return FALSE;
6107     }
6108
6109   if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6110     {
6111       if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6112         {
6113           (*_bfd_error_handler)
6114             (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
6115
6116           bfd_set_error (bfd_error_bad_value);
6117           return FALSE;
6118         }
6119     }
6120
6121   /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6122      and perf ext1 and DIV are mergerd to perf ext1.  */
6123   if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6124     {
6125       elf_elfheader (obfd)->e_flags =
6126         (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6127         | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6128         | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6129            ?  E_NDS32_HAS_EXT_INST : 0)
6130         | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6131            ?  E_NDS32_HAS_EXT_INST : 0)
6132         | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6133         | ((in_version > out_version) ? out_version : in_version);
6134     }
6135   else
6136     {
6137       if (in_version != out_version)
6138         (*_bfd_error_handler) (_("%B: warning: Incompatible elf-versions %s and  %s."),
6139                                  ibfd, nds32_elfver_strtab[out_version],
6140                                  nds32_elfver_strtab[in_version]);
6141
6142       elf_elfheader (obfd)->e_flags = in_flags | out_flags
6143         | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6144         | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6145         | (in_version > out_version ?  out_version : in_version);
6146     }
6147
6148   return TRUE;
6149 }
6150
6151 /* Display the flags field.  */
6152
6153 static bfd_boolean
6154 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6155 {
6156   FILE *file = (FILE *) ptr;
6157
6158   BFD_ASSERT (abfd != NULL && ptr != NULL);
6159
6160   _bfd_elf_print_private_bfd_data (abfd, ptr);
6161
6162   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6163
6164   switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6165     {
6166     default:
6167     case E_N1_ARCH:
6168       fprintf (file, _(": n1 instructions"));
6169       break;
6170     case E_N1H_ARCH:
6171       fprintf (file, _(": n1h instructions"));
6172       break;
6173     }
6174
6175   fputc ('\n', file);
6176
6177   return TRUE;
6178 }
6179
6180 static unsigned int
6181 nds32_elf_action_discarded (asection *sec)
6182 {
6183
6184   if (strncmp
6185       (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6186     return 0;
6187
6188   return _bfd_elf_default_action_discarded (sec);
6189 }
6190
6191 static asection *
6192 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6193                         Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6194                         Elf_Internal_Sym *sym)
6195 {
6196   if (h != NULL)
6197     switch (ELF32_R_TYPE (rel->r_info))
6198       {
6199       case R_NDS32_GNU_VTINHERIT:
6200       case R_NDS32_GNU_VTENTRY:
6201       case R_NDS32_RELA_GNU_VTINHERIT:
6202       case R_NDS32_RELA_GNU_VTENTRY:
6203         return NULL;
6204       }
6205
6206   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6207 }
6208
6209 static bfd_boolean
6210 nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
6211                          const Elf_Internal_Rela *relocs)
6212 {
6213   /* Update the got entry reference counts for the section being removed.  */
6214   Elf_Internal_Shdr *symtab_hdr;
6215   struct elf_link_hash_entry **sym_hashes;
6216   bfd_signed_vma *local_got_refcounts;
6217   const Elf_Internal_Rela *rel, *relend;
6218
6219   elf_section_data (sec)->local_dynrel = NULL;
6220
6221   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6222   sym_hashes = elf_sym_hashes (abfd);
6223   local_got_refcounts = elf_local_got_refcounts (abfd);
6224
6225   relend = relocs + sec->reloc_count;
6226   for (rel = relocs; rel < relend; rel++)
6227     {
6228       unsigned long r_symndx;
6229       struct elf_link_hash_entry *h = NULL;
6230
6231       r_symndx = ELF32_R_SYM (rel->r_info);
6232       if (r_symndx >= symtab_hdr->sh_info)
6233         {
6234           /* External symbol.  */
6235           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6236           while (h->root.type == bfd_link_hash_indirect
6237                  || h->root.type == bfd_link_hash_warning)
6238             h = (struct elf_link_hash_entry *) h->root.u.i.link;
6239         }
6240
6241       switch (ELF32_R_TYPE (rel->r_info))
6242         {
6243         case R_NDS32_GOT_HI20:
6244         case R_NDS32_GOT_LO12:
6245         case R_NDS32_GOT_LO15:
6246         case R_NDS32_GOT_LO19:
6247         case R_NDS32_GOT17S2_RELA:
6248         case R_NDS32_GOT15S2_RELA:
6249         case R_NDS32_GOTOFF:
6250         case R_NDS32_GOTOFF_HI20:
6251         case R_NDS32_GOTOFF_LO12:
6252         case R_NDS32_GOTOFF_LO15:
6253         case R_NDS32_GOTOFF_LO19:
6254         case R_NDS32_GOT20:
6255         case R_NDS32_GOTPC_HI20:
6256         case R_NDS32_GOTPC_LO12:
6257         case R_NDS32_GOTPC20:
6258           if (h != NULL)
6259             {
6260               if (h->got.refcount > 0)
6261                 h->got.refcount--;
6262             }
6263           else
6264             {
6265               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
6266                 local_got_refcounts[r_symndx]--;
6267             }
6268           break;
6269
6270         case R_NDS32_16_RELA:
6271         case R_NDS32_20_RELA:
6272         case R_NDS32_5_RELA:
6273         case R_NDS32_32_RELA:
6274         case R_NDS32_HI20_RELA:
6275         case R_NDS32_LO12S3_RELA:
6276         case R_NDS32_LO12S2_RELA:
6277         case R_NDS32_LO12S2_DP_RELA:
6278         case R_NDS32_LO12S2_SP_RELA:
6279         case R_NDS32_LO12S1_RELA:
6280         case R_NDS32_LO12S0_RELA:
6281         case R_NDS32_LO12S0_ORI_RELA:
6282         case R_NDS32_SDA16S3_RELA:
6283         case R_NDS32_SDA17S2_RELA:
6284         case R_NDS32_SDA18S1_RELA:
6285         case R_NDS32_SDA19S0_RELA:
6286         case R_NDS32_SDA15S3_RELA:
6287         case R_NDS32_SDA15S2_RELA:
6288         case R_NDS32_SDA12S2_DP_RELA:
6289         case R_NDS32_SDA12S2_SP_RELA:
6290         case R_NDS32_SDA15S1_RELA:
6291         case R_NDS32_SDA15S0_RELA:
6292         case R_NDS32_SDA_FP7U2_RELA:
6293         case R_NDS32_15_PCREL_RELA:
6294         case R_NDS32_17_PCREL_RELA:
6295         case R_NDS32_25_PCREL_RELA:
6296           if (h != NULL)
6297             {
6298               struct elf_nds32_link_hash_entry *eh;
6299               struct elf_nds32_dyn_relocs **pp;
6300               struct elf_nds32_dyn_relocs *p;
6301
6302               if (!info->shared && h->plt.refcount > 0)
6303                 h->plt.refcount -= 1;
6304
6305               eh = (struct elf_nds32_link_hash_entry *) h;
6306
6307               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6308                 if (p->sec == sec)
6309                   {
6310                     if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6311                         || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
6312                         || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
6313                       p->pc_count -= 1;
6314                     p->count -= 1;
6315                     if (p->count == 0)
6316                       *pp = p->next;
6317                     break;
6318                   }
6319             }
6320           break;
6321
6322         case R_NDS32_9_PLTREL:
6323         case R_NDS32_25_PLTREL:
6324           if (h != NULL)
6325             {
6326               if (h->plt.refcount > 0)
6327                 h->plt.refcount--;
6328             }
6329           break;
6330
6331         default:
6332           break;
6333         }
6334     }
6335
6336   return TRUE;
6337 }
6338
6339 /* Look through the relocs for a section during the first phase.
6340    Since we don't do .gots or .plts, we just need to consider the
6341    virtual table relocs for gc.  */
6342
6343 static bfd_boolean
6344 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6345                         asection *sec, const Elf_Internal_Rela *relocs)
6346 {
6347   Elf_Internal_Shdr *symtab_hdr;
6348   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6349   const Elf_Internal_Rela *rel;
6350   const Elf_Internal_Rela *rel_end;
6351   struct elf_nds32_link_hash_table *htab;
6352   bfd *dynobj;
6353   asection *sreloc = NULL;
6354
6355   if (info->relocatable)
6356     return TRUE;
6357
6358   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6359   sym_hashes = elf_sym_hashes (abfd);
6360   sym_hashes_end =
6361     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6362   if (!elf_bad_symtab (abfd))
6363     sym_hashes_end -= symtab_hdr->sh_info;
6364
6365   htab = nds32_elf_hash_table (info);
6366   dynobj = htab->root.dynobj;
6367
6368   rel_end = relocs + sec->reloc_count;
6369   for (rel = relocs; rel < rel_end; rel++)
6370     {
6371       enum elf_nds32_reloc_type r_type;
6372       struct elf_link_hash_entry *h;
6373       unsigned long r_symndx;
6374       int tls_type, old_tls_type;
6375
6376       r_symndx = ELF32_R_SYM (rel->r_info);
6377       r_type = ELF32_R_TYPE (rel->r_info);
6378       if (r_symndx < symtab_hdr->sh_info)
6379         h = NULL;
6380       else
6381         {
6382           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6383           while (h->root.type == bfd_link_hash_indirect
6384                  || h->root.type == bfd_link_hash_warning)
6385             h = (struct elf_link_hash_entry *) h->root.u.i.link;
6386         }
6387
6388       /* Some relocs require a global offset table.  We create
6389          got section here, since these relocation need got section
6390          and it is not created yet.  */
6391       if (htab->sgot == NULL)
6392         {
6393           switch (r_type)
6394             {
6395             case R_NDS32_GOT_HI20:
6396             case R_NDS32_GOT_LO12:
6397             case R_NDS32_GOT_LO15:
6398             case R_NDS32_GOT_LO19:
6399             case R_NDS32_GOT17S2_RELA:
6400             case R_NDS32_GOT15S2_RELA:
6401             case R_NDS32_GOTOFF:
6402             case R_NDS32_GOTOFF_HI20:
6403             case R_NDS32_GOTOFF_LO12:
6404             case R_NDS32_GOTOFF_LO15:
6405             case R_NDS32_GOTOFF_LO19:
6406             case R_NDS32_GOTPC20:
6407             case R_NDS32_GOTPC_HI20:
6408             case R_NDS32_GOTPC_LO12:
6409             case R_NDS32_GOT20:
6410             case R_NDS32_TLS_IE_HI20:
6411             case R_NDS32_TLS_IE_LO12S2:
6412               if (dynobj == NULL)
6413                 htab->root.dynobj = dynobj = abfd;
6414               if (!create_got_section (dynobj, info))
6415                 return FALSE;
6416               break;
6417
6418             default:
6419               break;
6420             }
6421         }
6422
6423       switch ((int) r_type)
6424         {
6425         case R_NDS32_GOT_HI20:
6426         case R_NDS32_GOT_LO12:
6427         case R_NDS32_GOT_LO15:
6428         case R_NDS32_GOT_LO19:
6429         case R_NDS32_GOT20:
6430         case R_NDS32_TLS_IE_HI20:
6431         case R_NDS32_TLS_IE_LO12S2:
6432           switch (r_type)
6433             {
6434             case R_NDS32_TLS_IE_HI20:
6435             case R_NDS32_TLS_IE_LO12S2:
6436               tls_type = GOT_TLS_IE;
6437               break;
6438             default:
6439               tls_type = GOT_NORMAL;
6440               break;
6441             }
6442           if (h != NULL)
6443             {
6444               old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6445               h->got.refcount += 1;
6446             }
6447           else
6448             {
6449               bfd_signed_vma *local_got_refcounts;
6450
6451               /* This is a global offset table entry for a local
6452                  symbol.  */
6453               local_got_refcounts = elf_local_got_refcounts (abfd);
6454               if (local_got_refcounts == NULL)
6455                 {
6456                   bfd_size_type size;
6457
6458                   size = symtab_hdr->sh_info;
6459                   size *= sizeof (bfd_signed_vma);
6460                   local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6461                   if (local_got_refcounts == NULL)
6462                     return FALSE;
6463                   elf_local_got_refcounts (abfd) = local_got_refcounts;
6464                 }
6465               local_got_refcounts[r_symndx] += 1;
6466               old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6467             }
6468
6469           /* We will already have issued an error message if there
6470              is a TLS/non-TLS mismatch, based on the symbol
6471              type.  So just combine any TLS types needed.  */
6472           if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6473               && tls_type != GOT_NORMAL)
6474             tls_type |= old_tls_type;
6475
6476           if (old_tls_type != tls_type)
6477             {
6478               if (h != NULL)
6479                 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6480               else
6481                 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6482             }
6483           break;
6484         case R_NDS32_9_PLTREL:
6485         case R_NDS32_25_PLTREL:
6486         case R_NDS32_PLTREL_HI20:
6487         case R_NDS32_PLTREL_LO12:
6488         case R_NDS32_PLT_GOTREL_HI20:
6489         case R_NDS32_PLT_GOTREL_LO12:
6490         case R_NDS32_PLT_GOTREL_LO15:
6491         case R_NDS32_PLT_GOTREL_LO19:
6492         case R_NDS32_PLT_GOTREL_LO20:
6493
6494           /* This symbol requires a procedure linkage table entry.  We
6495              actually build the entry in adjust_dynamic_symbol,
6496              because this might be a case of linking PIC code without
6497              linking in any dynamic objects, in which case we don't
6498              need to generate a procedure linkage table after all.  */
6499
6500           /* If this is a local symbol, we resolve it directly without
6501              creating a procedure linkage table entry.  */
6502           if (h == NULL)
6503             continue;
6504
6505           if (h->forced_local)
6506             break;
6507
6508           elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6509           h->needs_plt = 1;
6510           h->plt.refcount += 1;
6511           break;
6512
6513         case R_NDS32_16_RELA:
6514         case R_NDS32_20_RELA:
6515         case R_NDS32_5_RELA:
6516         case R_NDS32_32_RELA:
6517         case R_NDS32_HI20_RELA:
6518         case R_NDS32_LO12S3_RELA:
6519         case R_NDS32_LO12S2_RELA:
6520         case R_NDS32_LO12S2_DP_RELA:
6521         case R_NDS32_LO12S2_SP_RELA:
6522         case R_NDS32_LO12S1_RELA:
6523         case R_NDS32_LO12S0_RELA:
6524         case R_NDS32_LO12S0_ORI_RELA:
6525         case R_NDS32_SDA16S3_RELA:
6526         case R_NDS32_SDA17S2_RELA:
6527         case R_NDS32_SDA18S1_RELA:
6528         case R_NDS32_SDA19S0_RELA:
6529         case R_NDS32_SDA15S3_RELA:
6530         case R_NDS32_SDA15S2_RELA:
6531         case R_NDS32_SDA12S2_DP_RELA:
6532         case R_NDS32_SDA12S2_SP_RELA:
6533         case R_NDS32_SDA15S1_RELA:
6534         case R_NDS32_SDA15S0_RELA:
6535         case R_NDS32_SDA_FP7U2_RELA:
6536         case R_NDS32_15_PCREL_RELA:
6537         case R_NDS32_17_PCREL_RELA:
6538         case R_NDS32_25_PCREL_RELA:
6539
6540           if (h != NULL && !info->shared)
6541             {
6542               h->non_got_ref = 1;
6543               h->plt.refcount += 1;
6544             }
6545
6546           /* If we are creating a shared library, and this is a reloc against
6547              a global symbol, or a non PC relative reloc against a local
6548              symbol, then we need to copy the reloc into the shared library.
6549              However, if we are linking with -Bsymbolic, we do not need to
6550              copy a reloc against a global symbol which is defined in an
6551              object we are including in the link (i.e., DEF_REGULAR is set).
6552              At this point we have not seen all the input files, so it is
6553              possible that DEF_REGULAR is not set now but will be set later
6554              (it is never cleared).  We account for that possibility below by
6555              storing information in the dyn_relocs field of the hash table
6556              entry.  A similar situation occurs when creating shared libraries
6557              and symbol visibility changes render the symbol local.
6558
6559              If on the other hand, we are creating an executable, we may need
6560              to keep relocations for symbols satisfied by a dynamic library
6561              if we manage to avoid copy relocs for the symbol.  */
6562           if ((info->shared
6563                && (sec->flags & SEC_ALLOC) != 0
6564                && ((r_type != R_NDS32_25_PCREL_RELA
6565                     && r_type != R_NDS32_15_PCREL_RELA
6566                     && r_type != R_NDS32_17_PCREL_RELA
6567                     && !(r_type == R_NDS32_32_RELA
6568                          && strcmp (sec->name, ".eh_frame") == 0))
6569                    || (h != NULL
6570                        && (!info->symbolic
6571                            || h->root.type == bfd_link_hash_defweak
6572                            || !h->def_regular))))
6573               || (!info->shared
6574                   && (sec->flags & SEC_ALLOC) != 0
6575                   && h != NULL
6576                   && (h->root.type == bfd_link_hash_defweak
6577                       || !h->def_regular)))
6578             {
6579               struct elf_nds32_dyn_relocs *p;
6580               struct elf_nds32_dyn_relocs **head;
6581
6582               if (dynobj == NULL)
6583                 htab->root.dynobj = dynobj = abfd;
6584
6585               /* When creating a shared object, we must copy these
6586                  relocs into the output file.  We create a reloc
6587                  section in dynobj and make room for the reloc.  */
6588               if (sreloc == NULL)
6589                 {
6590                   const char *name;
6591
6592                   name = bfd_elf_string_from_elf_section
6593                     (abfd, elf_elfheader (abfd)->e_shstrndx,
6594                      elf_section_data (sec)->rela.hdr->sh_name);
6595                   if (name == NULL)
6596                     return FALSE;
6597
6598                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6599                               && strcmp (bfd_get_section_name (abfd, sec),
6600                                          name + 5) == 0);
6601
6602                   sreloc = bfd_get_section_by_name (dynobj, name);
6603                   if (sreloc == NULL)
6604                     {
6605                       flagword flags;
6606
6607                       sreloc = bfd_make_section (dynobj, name);
6608                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6609                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6610                       if ((sec->flags & SEC_ALLOC) != 0)
6611                         flags |= SEC_ALLOC | SEC_LOAD;
6612                       if (sreloc == NULL
6613                           || !bfd_set_section_flags (dynobj, sreloc, flags)
6614                           || !bfd_set_section_alignment (dynobj, sreloc, 2))
6615                         return FALSE;
6616
6617                       elf_section_type (sreloc) = SHT_RELA;
6618                     }
6619                   elf_section_data (sec)->sreloc = sreloc;
6620                 }
6621
6622               /* If this is a global symbol, we count the number of
6623                  relocations we need for this symbol.  */
6624               if (h != NULL)
6625                 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6626               else
6627                 {
6628                   asection *s;
6629
6630                   Elf_Internal_Sym *isym;
6631                   isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6632                   if (isym == NULL)
6633                     return FALSE;
6634
6635                   /* Track dynamic relocs needed for local syms too.  */
6636                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6637                   if (s == NULL)
6638                     return FALSE;
6639
6640                   head = ((struct elf_nds32_dyn_relocs **)
6641                         &elf_section_data (s)->local_dynrel);
6642                 }
6643
6644               p = *head;
6645               if (p == NULL || p->sec != sec)
6646                 {
6647                   bfd_size_type amt = sizeof (*p);
6648                   p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
6649                   if (p == NULL)
6650                     return FALSE;
6651                   p->next = *head;
6652                   *head = p;
6653                   p->sec = sec;
6654                   p->count = 0;
6655                   p->pc_count = 0;
6656                 }
6657
6658               p->count += 1;
6659               if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6660                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6661                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6662                 p->pc_count += 1;
6663             }
6664           break;
6665
6666           /* This relocation describes the C++ object vtable hierarchy.
6667              Reconstruct it for later use during GC.  */
6668         case R_NDS32_RELA_GNU_VTINHERIT:
6669         case R_NDS32_GNU_VTINHERIT:
6670           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6671             return FALSE;
6672           break;
6673
6674           /* This relocation describes which C++ vtable entries are actually
6675              used.  Record for later use during GC.  */
6676         case R_NDS32_GNU_VTENTRY:
6677           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6678             return FALSE;
6679           break;
6680         case R_NDS32_RELA_GNU_VTENTRY:
6681           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6682             return FALSE;
6683           break;
6684         }
6685     }
6686
6687   return TRUE;
6688 }
6689
6690 /* Write VAL in uleb128 format to P, returning a pointer to the
6691    following byte.
6692    This code is copied from elf-attr.c.  */
6693
6694 static bfd_byte *
6695 write_uleb128 (bfd_byte *p, unsigned int val)
6696 {
6697   bfd_byte c;
6698   do
6699     {
6700       c = val & 0x7f;
6701       val >>= 7;
6702       if (val)
6703         c |= 0x80;
6704       *(p++) = c;
6705     }
6706   while (val);
6707   return p;
6708 }
6709
6710 static bfd_signed_vma
6711 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6712                   Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6713                   int *pic_ext_target)
6714 {
6715   bfd_signed_vma foff;
6716   bfd_vma symval, addend;
6717   asection *sym_sec;
6718
6719   /* Get the value of the symbol referred to by the reloc.  */
6720   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6721     {
6722       Elf_Internal_Sym *isym;
6723
6724       /* A local symbol.  */
6725       isym = isymbuf + ELF32_R_SYM (irel->r_info);
6726
6727       if (isym->st_shndx == SHN_UNDEF)
6728         sym_sec = bfd_und_section_ptr;
6729       else if (isym->st_shndx == SHN_ABS)
6730         sym_sec = bfd_abs_section_ptr;
6731       else if (isym->st_shndx == SHN_COMMON)
6732         sym_sec = bfd_com_section_ptr;
6733       else
6734         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6735       symval = isym->st_value + sym_sec->output_section->vma
6736                + sym_sec->output_offset;
6737     }
6738   else
6739     {
6740       unsigned long indx;
6741       struct elf_link_hash_entry *h;
6742       bfd *owner;
6743
6744       /* An external symbol.  */
6745       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6746       h = elf_sym_hashes (abfd)[indx];
6747       BFD_ASSERT (h != NULL);
6748
6749       if (h->root.type != bfd_link_hash_defined
6750           && h->root.type != bfd_link_hash_defweak)
6751         /* This appears to be a reference to an undefined
6752            symbol.  Just ignore it--it will be caught by the
6753            regular reloc processing.  */
6754         return 0;
6755       owner = h->root.u.def.section->owner;
6756       if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6757         *pic_ext_target = 1;
6758
6759       if (h->root.u.def.section->flags & SEC_MERGE)
6760         {
6761           sym_sec = h->root.u.def.section;
6762           symval = _bfd_merged_section_offset (abfd, &sym_sec,
6763                                                elf_section_data (sym_sec)->sec_info,
6764                                                h->root.u.def.value);
6765           symval = symval + sym_sec->output_section->vma
6766                    + sym_sec->output_offset;
6767         }
6768       else
6769         symval = (h->root.u.def.value
6770                   + h->root.u.def.section->output_section->vma
6771                   + h->root.u.def.section->output_offset);
6772     }
6773
6774   addend = irel->r_addend;
6775
6776   foff = (symval + addend
6777           - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6778   return foff;
6779 }
6780
6781 static bfd_vma
6782 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6783                               Elf_Internal_Sym *isymbuf,
6784                               Elf_Internal_Rela *irel,
6785                               Elf_Internal_Shdr *symtab_hdr)
6786 {
6787   bfd_vma symval;
6788
6789   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6790     {
6791       Elf_Internal_Sym *isym;
6792       asection *sym_sec;
6793       /* A local symbol.  */
6794       isym = isymbuf + ELF32_R_SYM (irel->r_info);
6795
6796       if (isym->st_shndx == SHN_UNDEF)
6797         sym_sec = bfd_und_section_ptr;
6798       else if (isym->st_shndx == SHN_ABS)
6799         sym_sec = bfd_abs_section_ptr;
6800       else if (isym->st_shndx == SHN_COMMON)
6801         sym_sec = bfd_com_section_ptr;
6802       else
6803         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6804       symval = isym->st_value + sym_sec->output_section->vma
6805                + sym_sec->output_offset;
6806     }
6807   else
6808     {
6809       unsigned long indx;
6810       struct elf_link_hash_entry *h;
6811       struct elf_nds32_link_hash_table *htab;
6812       asection *splt;
6813
6814       /* An external symbol.  */
6815       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6816       h = elf_sym_hashes (abfd)[indx];
6817       BFD_ASSERT (h != NULL);
6818       htab = nds32_elf_hash_table (link_info);
6819       splt = htab->splt;
6820
6821       while (h->root.type == bfd_link_hash_indirect
6822              || h->root.type == bfd_link_hash_warning)
6823         h = (struct elf_link_hash_entry *) h->root.u.i.link;
6824
6825       if (h->plt.offset == (bfd_vma) - 1)
6826         {
6827           if (h->root.type != bfd_link_hash_defined
6828               && h->root.type != bfd_link_hash_defweak)
6829             /* This appears to be a reference to an undefined
6830              * symbol.  Just ignore it--it will be caught by the
6831              * regular reloc processing.  */
6832             return 0;
6833           symval = (h->root.u.def.value
6834                     + h->root.u.def.section->output_section->vma
6835                     + h->root.u.def.section->output_offset);
6836         }
6837       else
6838         symval = splt->output_section->vma + h->plt.offset;
6839     }
6840
6841   return symval;
6842 }
6843
6844 static bfd_signed_vma
6845 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6846                       Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6847                       Elf_Internal_Shdr *symtab_hdr)
6848 {
6849   bfd_vma foff;
6850   if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6851                                             symtab_hdr)) == 0)
6852     return 0;
6853   else
6854     return foff - (irel->r_offset
6855                    + sec->output_section->vma + sec->output_offset);
6856 }
6857 \f
6858 /* Convert a 32-bit instruction to 16-bit one.
6859    INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6860    instruction.  If INSN_TYPE is not NULL, it the CGEN instruction
6861    type of INSN16.  Return 1 if successful.  */
6862
6863 static int
6864 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6865                              int *pinsn_type)
6866 {
6867   uint16_t insn16 = 0;
6868   int insn_type;
6869   unsigned long mach = bfd_get_mach (abfd);
6870
6871   if (N32_SH5 (insn) != 0)
6872     return 0;
6873
6874   switch (N32_SUB5 (insn))
6875     {
6876     case N32_ALU1_ADD_SLLI:
6877     case N32_ALU1_ADD_SRLI:
6878       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6879         {
6880           insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6881                                 N32_RB5 (insn));
6882           insn_type = NDS32_INSN_ADD333;
6883         }
6884       else if (N32_IS_RT4 (insn))
6885         {
6886           if (N32_RT5 (insn) == N32_RA5 (insn))
6887             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6888           else if (N32_RT5 (insn) == N32_RB5 (insn))
6889             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6890           insn_type = NDS32_INSN_ADD45;
6891         }
6892       break;
6893
6894     case N32_ALU1_SUB_SLLI:
6895     case N32_ALU1_SUB_SRLI:
6896       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6897         {
6898           insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6899                                 N32_RB5 (insn));
6900           insn_type = NDS32_INSN_SUB333;
6901         }
6902       else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6903         {
6904           insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6905           insn_type = NDS32_INSN_SUB45;
6906         }
6907       break;
6908
6909     case N32_ALU1_AND_SLLI:
6910     case N32_ALU1_AND_SRLI:
6911       /* and $rt, $rt, $rb -> and33 for v3, v3m.  */
6912       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6913           && N32_IS_RB3 (insn))
6914         {
6915           if (N32_RT5 (insn) == N32_RA5 (insn))
6916             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6917           else if (N32_RT5 (insn) == N32_RB5 (insn))
6918             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6919           if (insn16)
6920             insn_type = NDS32_INSN_AND33;
6921         }
6922       break;
6923
6924     case N32_ALU1_XOR_SLLI:
6925     case N32_ALU1_XOR_SRLI:
6926       /* xor $rt, $rt, $rb -> xor33 for v3, v3m.  */
6927       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6928           && N32_IS_RB3 (insn))
6929         {
6930           if (N32_RT5 (insn) == N32_RA5 (insn))
6931             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6932           else if (N32_RT5 (insn) == N32_RB5 (insn))
6933             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6934           if (insn16)
6935             insn_type = NDS32_INSN_XOR33;
6936         }
6937       break;
6938
6939     case N32_ALU1_OR_SLLI:
6940     case N32_ALU1_OR_SRLI:
6941       /* or $rt, $rt, $rb -> or33 for v3, v3m.  */
6942       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6943           && N32_IS_RB3 (insn))
6944         {
6945           if (N32_RT5 (insn) == N32_RA5 (insn))
6946             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6947           else if (N32_RT5 (insn) == N32_RB5 (insn))
6948             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6949           if (insn16)
6950             insn_type = NDS32_INSN_OR33;
6951         }
6952       break;
6953     case N32_ALU1_NOR:
6954       /* nor $rt, $ra, $ra -> not33 for v3, v3m.  */
6955       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6956           && N32_RA5 (insn) == N32_RB5 (insn))
6957         {
6958           insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6959           insn_type = NDS32_INSN_NOT33;
6960         }
6961       break;
6962     case N32_ALU1_SRAI:
6963       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6964         {
6965           insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6966           insn_type = NDS32_INSN_SRAI45;
6967         }
6968       break;
6969
6970     case N32_ALU1_SRLI:
6971       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6972         {
6973           insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6974           insn_type = NDS32_INSN_SRLI45;
6975         }
6976       break;
6977
6978     case N32_ALU1_SLLI:
6979       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6980         {
6981           insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6982                                 N32_UB5 (insn));
6983           insn_type = NDS32_INSN_SLLI333;
6984         }
6985       break;
6986
6987     case N32_ALU1_ZEH:
6988       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6989         {
6990           insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6991           insn_type = NDS32_INSN_ZEH33;
6992         }
6993       break;
6994
6995     case N32_ALU1_SEB:
6996       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6997         {
6998           insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
6999           insn_type = NDS32_INSN_SEB33;
7000         }
7001       break;
7002
7003     case N32_ALU1_SEH:
7004       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7005         {
7006           insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7007           insn_type = NDS32_INSN_SEH33;
7008         }
7009       break;
7010
7011     case N32_ALU1_SLT:
7012       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7013         {
7014           /* Implicit r15.  */
7015           insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7016           insn_type = NDS32_INSN_SLT45;
7017         }
7018       break;
7019
7020     case N32_ALU1_SLTS:
7021       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7022         {
7023           /* Implicit r15.  */
7024           insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7025           insn_type = NDS32_INSN_SLTS45;
7026         }
7027       break;
7028     }
7029
7030   if ((insn16 & 0x8000) == 0)
7031     return 0;
7032
7033   if (pinsn16)
7034     *pinsn16 = insn16;
7035   if (pinsn_type)
7036     *pinsn_type = insn_type;
7037   return 1;
7038 }
7039
7040 static int
7041 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7042                              int *pinsn_type)
7043 {
7044   uint16_t insn16 = 0;
7045   int insn_type;
7046   unsigned long mach = bfd_get_mach (abfd);
7047
7048   /* TODO: bset, bclr, btgl, btst.  */
7049   if (__GF (insn, 6, 4) != 0)
7050     return 0;
7051
7052   switch (N32_IMMU (insn, 6))
7053     {
7054     case N32_ALU2_MUL:
7055       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7056           && N32_IS_RB3 (insn))
7057         {
7058           if (N32_RT5 (insn) == N32_RA5 (insn))
7059             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7060           else if (N32_RT5 (insn) == N32_RB5 (insn))
7061             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7062           if (insn16)
7063             insn_type = NDS32_INSN_MUL33;
7064         }
7065     }
7066
7067   if ((insn16 & 0x8000) == 0)
7068     return 0;
7069
7070   if (pinsn16)
7071     *pinsn16 = insn16;
7072   if (pinsn_type)
7073     *pinsn_type = insn_type;
7074   return 1;
7075 }
7076
7077 int
7078 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7079                         int *pinsn_type)
7080 {
7081   int op6;
7082   uint16_t insn16 = 0;
7083   int insn_type;
7084   unsigned long mach = bfd_get_mach (abfd);
7085
7086   /* Decode 32-bit instruction.  */
7087   if (insn & 0x80000000)
7088     {
7089       /* Not 32-bit insn.  */
7090       return 0;
7091     }
7092
7093   op6 = N32_OP6 (insn);
7094
7095   /* Convert it to 16-bit instruction.  */
7096   switch (op6)
7097     {
7098     case N32_OP6_MOVI:
7099       if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7100         {
7101           insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7102           insn_type = NDS32_INSN_MOVI55;
7103         }
7104       else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7105                && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7106         {
7107           insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7108                                N32_IMM20S (insn) - 16);
7109           insn_type = NDS32_INSN_MOVPI45;
7110         }
7111       break;
7112
7113     case N32_OP6_ADDI:
7114       if (N32_IMM15S (insn) == 0)
7115         {
7116           /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7117              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7118           if (mach <= MACH_V2
7119               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7120             {
7121               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7122               insn_type = NDS32_INSN_MOV55;
7123             }
7124         }
7125       else if (N32_IMM15S (insn) > 0)
7126         {
7127           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7128             {
7129               insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7130                                     N32_IMM15S (insn));
7131               insn_type = NDS32_INSN_ADDI333;
7132             }
7133           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7134                    && N32_IMM15S (insn) < 32)
7135             {
7136               insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7137               insn_type = NDS32_INSN_ADDI45;
7138             }
7139           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7140                    && N32_RT5 (insn) == N32_RA5 (insn)
7141                    && N32_IMM15S (insn) < 512)
7142             {
7143               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7144               insn_type = NDS32_INSN_ADDI10_SP;
7145             }
7146           else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7147                    && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7148                    && (N32_IMM15S (insn) % 4 == 0))
7149             {
7150               insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7151                                    N32_IMM15S (insn) >> 2);
7152               insn_type = NDS32_INSN_ADDRI36_SP;
7153             }
7154         }
7155       else
7156         {
7157           /* Less than 0.  */
7158           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7159             {
7160               insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7161                                     0 - N32_IMM15S (insn));
7162               insn_type = NDS32_INSN_SUBI333;
7163             }
7164           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7165                    && N32_IMM15S (insn) > -32)
7166             {
7167               insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7168                                    0 - N32_IMM15S (insn));
7169               insn_type = NDS32_INSN_SUBI45;
7170             }
7171           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7172                    && N32_RT5 (insn) == N32_RA5 (insn)
7173                    && N32_IMM15S (insn) >= -512)
7174             {
7175               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7176               insn_type = NDS32_INSN_ADDI10_SP;
7177             }
7178         }
7179       break;
7180
7181     case N32_OP6_ORI:
7182       if (N32_IMM15S (insn) == 0)
7183         {
7184           /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7185              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7186           if (mach <= MACH_V2
7187               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7188             {
7189               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7190               insn_type = NDS32_INSN_MOV55;
7191             }
7192         }
7193       break;
7194
7195     case N32_OP6_SUBRI:
7196       if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7197           && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7198         {
7199           insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7200           insn_type = NDS32_INSN_NEG33;
7201         }
7202       break;
7203
7204     case N32_OP6_ANDI:
7205       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7206         {
7207           if (N32_IMM15U (insn) == 1)
7208             {
7209               insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7210               insn_type = NDS32_INSN_XLSB33;
7211             }
7212           else if (N32_IMM15U (insn) == 0x7ff)
7213             {
7214               insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7215               insn_type = NDS32_INSN_X11B33;
7216             }
7217           else if (N32_IMM15U (insn) == 0xff)
7218             {
7219               insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7220               insn_type = NDS32_INSN_ZEB33;
7221             }
7222           else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7223                    && N32_IMM15U (insn) < 256)
7224             {
7225               int imm15u = N32_IMM15U (insn);
7226
7227               if (__builtin_popcount (imm15u) == 1)
7228                 {
7229                   /* BMSKI33 */
7230                   int imm3u = __builtin_ctz (imm15u);
7231
7232                   insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7233                   insn_type = NDS32_INSN_BMSKI33;
7234                 }
7235               else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7236                 {
7237                   /* FEXTI33 */
7238                   int imm3u = __builtin_ctz (imm15u + 1) - 1;
7239
7240                   insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7241                   insn_type = NDS32_INSN_FEXTI33;
7242                 }
7243             }
7244         }
7245       break;
7246
7247     case N32_OP6_SLTI:
7248       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7249           && IS_WITHIN_U (N32_IMM15S (insn), 5))
7250         {
7251           insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7252           insn_type = NDS32_INSN_SLTI45;
7253         }
7254       break;
7255
7256     case N32_OP6_SLTSI:
7257       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7258           && IS_WITHIN_U (N32_IMM15S (insn), 5))
7259         {
7260           insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7261           insn_type = NDS32_INSN_SLTSI45;
7262         }
7263       break;
7264
7265     case N32_OP6_LWI:
7266       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7267         {
7268           insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7269           insn_type = NDS32_INSN_LWI450;
7270         }
7271       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7272                && IS_WITHIN_U (N32_IMM15S (insn), 3))
7273         {
7274           insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7275                                 N32_IMM15S (insn));
7276           insn_type = NDS32_INSN_LWI333;
7277         }
7278       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7279                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7280         {
7281           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7282           insn_type = NDS32_INSN_LWI37;
7283         }
7284       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7285                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7286         {
7287           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7288           insn_type = NDS32_INSN_LWI37_SP;
7289         }
7290       else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7291                && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7292         {
7293           insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7294                                N32_IMM15S (insn) + 32);
7295           insn_type = NDS32_INSN_LWI45_FE;
7296         }
7297       break;
7298
7299     case N32_OP6_SWI:
7300       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7301         {
7302           insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7303           insn_type = NDS32_INSN_SWI450;
7304         }
7305       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7306                && IS_WITHIN_U (N32_IMM15S (insn), 3))
7307         {
7308           insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7309                                 N32_IMM15S (insn));
7310           insn_type = NDS32_INSN_SWI333;
7311         }
7312       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7313                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7314         {
7315           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7316           insn_type = NDS32_INSN_SWI37;
7317         }
7318       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7319                && IS_WITHIN_U (N32_IMM15S (insn), 7))
7320         {
7321           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7322           insn_type = NDS32_INSN_SWI37_SP;
7323         }
7324       break;
7325
7326     case N32_OP6_LWI_BI:
7327       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7328           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7329         {
7330           insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7331                                 N32_IMM15S (insn));
7332           insn_type = NDS32_INSN_LWI333_BI;
7333         }
7334       break;
7335
7336     case N32_OP6_SWI_BI:
7337       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7338           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7339         {
7340           insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7341                                 N32_IMM15S (insn));
7342           insn_type = NDS32_INSN_SWI333_BI;
7343         }
7344       break;
7345
7346     case N32_OP6_LHI:
7347       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7348           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7349         {
7350           insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7351                                 N32_IMM15S (insn));
7352           insn_type = NDS32_INSN_LHI333;
7353         }
7354       break;
7355
7356     case N32_OP6_SHI:
7357       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7358           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7359         {
7360           insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7361                                 N32_IMM15S (insn));
7362           insn_type = NDS32_INSN_SHI333;
7363         }
7364       break;
7365
7366     case N32_OP6_LBI:
7367       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7368           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7369         {
7370           insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7371                                 N32_IMM15S (insn));
7372           insn_type = NDS32_INSN_LBI333;
7373         }
7374       break;
7375
7376     case N32_OP6_SBI:
7377       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7378           && IS_WITHIN_U (N32_IMM15S (insn), 3))
7379         {
7380           insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7381                                 N32_IMM15S (insn));
7382           insn_type = NDS32_INSN_SBI333;
7383         }
7384       break;
7385
7386     case N32_OP6_ALU1:
7387       return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7388
7389     case N32_OP6_ALU2:
7390       return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7391
7392     case N32_OP6_BR1:
7393       if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7394         goto done;
7395
7396       if ((insn & __BIT (14)) == 0)
7397         {
7398           /* N32_BR1_BEQ */
7399           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7400               && N32_RT5 (insn) != REG_R5)
7401             insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7402           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7403                    && N32_RA5 (insn) != REG_R5)
7404             insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7405           insn_type = NDS32_INSN_BEQS38;
7406           break;
7407         }
7408       else
7409         {
7410           /* N32_BR1_BNE */
7411           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7412               && N32_RT5 (insn) != REG_R5)
7413             insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7414           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7415                    && N32_RA5 (insn) != REG_R5)
7416             insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7417           insn_type = NDS32_INSN_BNES38;
7418           break;
7419         }
7420       break;
7421
7422     case N32_OP6_BR2:
7423       switch (N32_BR2_SUB (insn))
7424         {
7425         case N32_BR2_BEQZ:
7426           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7427             {
7428               insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7429               insn_type = NDS32_INSN_BEQZ38;
7430             }
7431           else if (N32_RT5 (insn) == REG_R15
7432                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
7433             {
7434               insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7435               insn_type = NDS32_INSN_BEQZS8;
7436             }
7437           break;
7438
7439         case N32_BR2_BNEZ:
7440           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7441             {
7442               insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7443               insn_type = NDS32_INSN_BNEZ38;
7444             }
7445           else if (N32_RT5 (insn) == REG_R15
7446                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
7447             {
7448               insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7449               insn_type = NDS32_INSN_BNEZS8;
7450             }
7451           break;
7452
7453         case N32_BR2_IFCALL:
7454           if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7455             {
7456               insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7457               insn_type = NDS32_INSN_IFCALL9;
7458             }
7459           break;
7460         }
7461       break;
7462
7463     case N32_OP6_JI:
7464       if ((insn & __BIT (24)) == 0)
7465         {
7466           /* N32_JI_J */
7467           if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7468             {
7469               insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7470               insn_type = NDS32_INSN_J8;
7471             }
7472         }
7473       break;
7474
7475     case N32_OP6_JREG:
7476       if (__GF (insn, 8, 2) != 0)
7477         goto done;
7478
7479       switch (N32_IMMU (insn, 5))
7480         {
7481         case N32_JREG_JR:
7482           if (N32_JREG_HINT (insn) == 0)
7483             {
7484               /* jr */
7485               insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7486               insn_type = NDS32_INSN_JR5;
7487             }
7488           else if (N32_JREG_HINT (insn) == 1)
7489             {
7490               /* ret */
7491               insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7492               insn_type = NDS32_INSN_RET5;
7493             }
7494           else if (N32_JREG_HINT (insn) == 3)
7495             {
7496               /* ifret = mov55 $sp, $sp */
7497               insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7498               insn_type = NDS32_INSN_IFRET;
7499             }
7500           break;
7501
7502         case N32_JREG_JRAL:
7503           /* It's convertible when return rt5 is $lp and address
7504              translation is kept.  */
7505           if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7506             {
7507               insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7508               insn_type = NDS32_INSN_JRAL5;
7509             }
7510           break;
7511         }
7512       break;
7513
7514     case N32_OP6_MISC:
7515       if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7516         {
7517           /* For v3, swid above 31 are used for ex9.it.  */
7518           insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7519           insn_type = NDS32_INSN_BREAK16;
7520         }
7521       break;
7522
7523     default:
7524       /* This instruction has no 16-bit variant.  */
7525       goto done;
7526     }
7527
7528 done:
7529   /* Bit-15 of insn16 should be set for a valid instruction.  */
7530   if ((insn16 & 0x8000) == 0)
7531     return 0;
7532
7533   if (pinsn16)
7534     *pinsn16 = insn16;
7535   if (pinsn_type)
7536     *pinsn_type = insn_type;
7537   return 1;
7538 }
7539
7540 static int
7541 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7542                           Elf_Internal_Rela *reloc)
7543 {
7544   uint16_t insn16 = 0;
7545
7546   if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7547       || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7548     return 0;
7549
7550   if (!N32_IS_RT3 (insn))
7551     return 0;
7552
7553   switch (N32_OP6 (insn))
7554     {
7555     case N32_OP6_LWI:
7556       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7557         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7558       break;
7559     case N32_OP6_SWI:
7560       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7561         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7562       break;
7563     case N32_OP6_HWGP:
7564       if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7565         break;
7566
7567       if (__GF (insn, 17, 3) == 6)
7568         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7569       else if (__GF (insn, 17, 3) == 7)
7570         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7571       break;
7572     }
7573
7574   if ((insn16 & 0x8000) == 0)
7575     return 0;
7576
7577   *pinsn16 = insn16;
7578   return 1;
7579 }
7580
7581 /* Convert a 16-bit instruction to 32-bit one.
7582    INSN16 it the input and PINSN it the point to output.
7583    Return non-zero on successful.  Otherwise 0 is returned.  */
7584
7585 int
7586 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7587 {
7588   uint32_t insn = 0xffffffff;
7589   unsigned long mach = bfd_get_mach (abfd);
7590
7591   /* NOTE: push25, pop25 and movd44 do not have 32-bit variants.  */
7592
7593   switch (__GF (insn16, 9, 6))
7594     {
7595     case 0x4:                   /* add45 */
7596       insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7597                        N16_RA5 (insn16));
7598       goto done;
7599     case 0x5:                   /* sub45 */
7600       insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7601                        N16_RA5 (insn16));
7602       goto done;
7603     case 0x6:                   /* addi45 */
7604       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7605                         N16_IMM5U (insn16));
7606       goto done;
7607     case 0x7:                   /* subi45 */
7608       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7609                         -N16_IMM5U (insn16));
7610       goto done;
7611     case 0x8:                   /* srai45 */
7612       insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7613                        N16_IMM5U (insn16));
7614       goto done;
7615     case 0x9:                   /* srli45 */
7616       insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7617                        N16_IMM5U (insn16));
7618       goto done;
7619     case 0xa:                   /* slli333 */
7620       insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7621                        N16_IMM3U (insn16));
7622       goto done;
7623     case 0xc:                   /* add333 */
7624       insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7625                        N16_RB3 (insn16));
7626       goto done;
7627     case 0xd:                   /* sub333 */
7628       insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7629                        N16_RB3 (insn16));
7630       goto done;
7631     case 0xe:                   /* addi333 */
7632       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7633                         N16_IMM3U (insn16));
7634       goto done;
7635     case 0xf:                   /* subi333 */
7636       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7637                         -N16_IMM3U (insn16));
7638       goto done;
7639     case 0x10:                  /* lwi333 */
7640       insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7641                         N16_IMM3U (insn16));
7642       goto done;
7643     case 0x12:                  /* lhi333 */
7644       insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7645                         N16_IMM3U (insn16));
7646       goto done;
7647     case 0x13:                  /* lbi333 */
7648       insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7649                         N16_IMM3U (insn16));
7650       goto done;
7651     case 0x11:                  /* lwi333.bi */
7652       insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7653                         N16_IMM3U (insn16));
7654       goto done;
7655     case 0x14:                  /* swi333 */
7656       insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7657                         N16_IMM3U (insn16));
7658       goto done;
7659     case 0x16:                  /* shi333 */
7660       insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7661                         N16_IMM3U (insn16));
7662       goto done;
7663     case 0x17:                  /* sbi333 */
7664       insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7665                         N16_IMM3U (insn16));
7666       goto done;
7667     case 0x15:                  /* swi333.bi */
7668       insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7669                         N16_IMM3U (insn16));
7670       goto done;
7671     case 0x18:                  /* addri36.sp */
7672       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7673                         N16_IMM6U (insn16) << 2);
7674       goto done;
7675     case 0x19:                  /* lwi45.fe */
7676       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7677                         (N16_IMM5U (insn16) - 32));
7678       goto done;
7679     case 0x1a:                  /* lwi450 */
7680       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7681       goto done;
7682     case 0x1b:                  /* swi450 */
7683       insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7684       goto done;
7685
7686       /* These are r15 implied instructions.  */
7687     case 0x30:                  /* slts45 */
7688       insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7689       goto done;
7690     case 0x31:                  /* slt45 */
7691       insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7692       goto done;
7693     case 0x32:                  /* sltsi45 */
7694       insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7695       goto done;
7696     case 0x33:                  /* slti45 */
7697       insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7698       goto done;
7699     case 0x34:                  /* beqzs8, bnezs8 */
7700       if (insn16 & __BIT (8))
7701         insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7702       else
7703         insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7704       goto done;
7705
7706     case 0x35:                  /* break16, ex9.it */
7707       /* Only consider range of v3 break16.  */
7708       insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7709       goto done;
7710
7711     case 0x3c:                  /* ifcall9 */
7712       insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7713       goto done;
7714     case 0x3d:                  /* movpi45 */
7715       insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7716       goto done;
7717
7718     case 0x3f:                  /* MISC33 */
7719       switch (insn16 & 0x7)
7720         {
7721         case 2:                 /* neg33 */
7722           insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7723           break;
7724         case 3:                 /* not33 */
7725           insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7726                            N16_RA3 (insn16));
7727           break;
7728         case 4:                 /* mul33 */
7729           insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7730                            N16_RA3 (insn16));
7731           break;
7732         case 5:                 /* xor33 */
7733           insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7734                            N16_RA3 (insn16));
7735           break;
7736         case 6:                 /* and33 */
7737           insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7738                            N16_RA3 (insn16));
7739           break;
7740         case 7:                 /* or33 */
7741           insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7742                            N16_RA3 (insn16));
7743           break;
7744         }
7745       goto done;
7746
7747     case 0xb:
7748       switch (insn16 & 0x7)
7749         {
7750         case 0:                 /* zeb33 */
7751           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7752           break;
7753         case 1:                 /* zeh33 */
7754           insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7755           break;
7756         case 2:                 /* seb33 */
7757           insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7758           break;
7759         case 3:                 /* seh33 */
7760           insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7761           break;
7762         case 4:                 /* xlsb33 */
7763           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7764           break;
7765         case 5:                 /* x11b33 */
7766           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7767           break;
7768         case 6:                 /* bmski33 */
7769           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7770                             1 << __GF (insn16, 3, 3));
7771           break;
7772         case 7:                 /* fexti33 */
7773           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7774                             (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7775           break;
7776         }
7777       goto done;
7778     }
7779
7780   switch (__GF (insn16, 10, 5))
7781     {
7782     case 0x0:                   /* mov55 or ifret16 */
7783       if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7784           && N16_RT5 (insn16) == N16_RA5 (insn16))
7785         insn = N32_JREG (JR, 0, 0, 0, 3);
7786       else
7787         insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7788       goto done;
7789     case 0x1:                   /* movi55 */
7790       insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7791       goto done;
7792     case 0x1b:                  /* addi10s (V2) */
7793       insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7794       goto done;
7795     }
7796
7797   switch (__GF (insn16, 11, 4))
7798     {
7799     case 0x7:                   /* lwi37.fp/swi37.fp */
7800       if (insn16 & __BIT (7))   /* swi37.fp */
7801         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7802       else                      /* lwi37.fp */
7803         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7804       goto done;
7805     case 0x8:                   /* beqz38 */
7806       insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7807       goto done;
7808     case 0x9:                   /* bnez38 */
7809       insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7810       goto done;
7811     case 0xa:                   /* beqs38/j8, implied r5 */
7812       if (N16_RT38 (insn16) == 5)
7813         insn = N32_JI (J, N16_IMM8S (insn16));
7814       else
7815         insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7816       goto done;
7817     case 0xb:                   /* bnes38 and others */
7818       if (N16_RT38 (insn16) == 5)
7819         {
7820           switch (__GF (insn16, 5, 3))
7821             {
7822             case 0:             /* jr5 */
7823               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7824               break;
7825             case 4:             /* ret5 */
7826               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7827               break;
7828             case 1:             /* jral5 */
7829               insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7830               break;
7831             case 2:             /* ex9.it imm5 */
7832               /* ex9.it had no 32-bit variantl.  */
7833               break;
7834             case 5:             /* add5.pc */
7835               /* add5.pc had no 32-bit variantl.  */
7836               break;
7837             }
7838         }
7839       else                      /* bnes38 */
7840         insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7841       goto done;
7842     case 0xe:                   /* lwi37/swi37 */
7843       if (insn16 & (1 << 7))    /* swi37.sp */
7844         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7845       else                      /* lwi37.sp */
7846         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7847       goto done;
7848     }
7849
7850 done:
7851   if (insn & 0x80000000)
7852     return 0;
7853
7854   if (pinsn)
7855     *pinsn = insn;
7856   return 1;
7857 }
7858 \f
7859 static bfd_boolean
7860 is_sda_access_insn (unsigned long insn)
7861 {
7862   switch (N32_OP6 (insn))
7863     {
7864     case N32_OP6_LWI:
7865     case N32_OP6_LHI:
7866     case N32_OP6_LHSI:
7867     case N32_OP6_LBI:
7868     case N32_OP6_LBSI:
7869     case N32_OP6_SWI:
7870     case N32_OP6_SHI:
7871     case N32_OP6_SBI:
7872     case N32_OP6_LWC:
7873     case N32_OP6_LDC:
7874     case N32_OP6_SWC:
7875     case N32_OP6_SDC:
7876       return TRUE;
7877     default:
7878       ;
7879     }
7880   return FALSE;
7881 }
7882
7883 static unsigned long
7884 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7885 {
7886   uint32_t oinsn = 0;
7887
7888   switch (type)
7889     {
7890     case R_NDS32_GOT_LO12:
7891     case R_NDS32_GOTOFF_LO12:
7892     case R_NDS32_PLTREL_LO12:
7893     case R_NDS32_PLT_GOTREL_LO12:
7894     case R_NDS32_LO12S0_RELA:
7895       switch (N32_OP6 (insn))
7896         {
7897         case N32_OP6_LBI:
7898           /* lbi.gp */
7899           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7900           break;
7901         case N32_OP6_LBSI:
7902           /* lbsi.gp */
7903           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
7904           break;
7905         case N32_OP6_SBI:
7906           /* sbi.gp */
7907           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7908           break;
7909         case N32_OP6_ORI:
7910           /* addi.gp */
7911           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
7912           break;
7913         }
7914       break;
7915
7916     case R_NDS32_LO12S1_RELA:
7917       switch (N32_OP6 (insn))
7918         {
7919         case N32_OP6_LHI:
7920           /* lhi.gp */
7921           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7922           break;
7923         case N32_OP6_LHSI:
7924           /* lhsi.gp */
7925           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
7926           break;
7927         case N32_OP6_SHI:
7928           /* shi.gp */
7929           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
7930           break;
7931         }
7932       break;
7933
7934     case R_NDS32_LO12S2_RELA:
7935       switch (N32_OP6 (insn))
7936         {
7937         case N32_OP6_LWI:
7938           /* lwi.gp */
7939           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7940           break;
7941         case N32_OP6_SWI:
7942           /* swi.gp */
7943           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7944           break;
7945         }
7946       break;
7947
7948     case R_NDS32_LO12S2_DP_RELA:
7949     case R_NDS32_LO12S2_SP_RELA:
7950       oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7951       break;
7952     }
7953
7954   if (oinsn)
7955     *pinsn = oinsn;
7956
7957   return oinsn != 0;
7958 }
7959
7960 /* Linker hasn't found the correct merge section for non-section symbol
7961    in relax time, this work is left to the function elf_link_input_bfd().
7962    So for non-section symbol, _bfd_merged_section_offset is also needed
7963    to find the correct symbol address.  */
7964
7965 static bfd_vma
7966 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7967                           asection **psec, Elf_Internal_Rela *rel)
7968 {
7969   asection *sec = *psec;
7970   bfd_vma relocation;
7971
7972   relocation = (sec->output_section->vma
7973                 + sec->output_offset + sym->st_value);
7974   if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7975     {
7976       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7977         rel->r_addend =
7978           _bfd_merged_section_offset (abfd, psec,
7979                                       elf_section_data (sec)->sec_info,
7980                                       sym->st_value + rel->r_addend);
7981       else
7982         rel->r_addend =
7983           _bfd_merged_section_offset (abfd, psec,
7984                                       elf_section_data (sec)->sec_info,
7985                                       sym->st_value) + rel->r_addend;
7986
7987       if (sec != *psec)
7988         {
7989           /* If we have changed the section, and our original section is
7990              marked with SEC_EXCLUDE, it means that the original
7991              SEC_MERGE section has been completely subsumed in some
7992              other SEC_MERGE section.  In this case, we need to leave
7993              some info around for --emit-relocs.  */
7994           if ((sec->flags & SEC_EXCLUDE) != 0)
7995             sec->kept_section = *psec;
7996           sec = *psec;
7997         }
7998       rel->r_addend -= relocation;
7999       rel->r_addend += sec->output_section->vma + sec->output_offset;
8000     }
8001   return relocation;
8002 }
8003
8004 static bfd_vma
8005 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8006                           Elf_Internal_Sym *isymbuf,
8007                           Elf_Internal_Shdr *symtab_hdr)
8008 {
8009   bfd_signed_vma foff;
8010   bfd_vma symval, addend;
8011   Elf_Internal_Rela irel_fn;
8012   Elf_Internal_Sym *isym;
8013   asection *sym_sec;
8014
8015   /* Get the value of the symbol referred to by the reloc.  */
8016   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8017     {
8018       /* A local symbol.  */
8019       isym = isymbuf + ELF32_R_SYM (irel->r_info);
8020
8021       if (isym->st_shndx == SHN_UNDEF)
8022         sym_sec = bfd_und_section_ptr;
8023       else if (isym->st_shndx == SHN_ABS)
8024         sym_sec = bfd_abs_section_ptr;
8025       else if (isym->st_shndx == SHN_COMMON)
8026         sym_sec = bfd_com_section_ptr;
8027       else
8028         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8029       memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8030       symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8031       addend = irel_fn.r_addend;
8032     }
8033   else
8034     {
8035       unsigned long indx;
8036       struct elf_link_hash_entry *h;
8037
8038       /* An external symbol.  */
8039       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8040       h = elf_sym_hashes (abfd)[indx];
8041       BFD_ASSERT (h != NULL);
8042
8043       while (h->root.type == bfd_link_hash_indirect
8044              || h->root.type == bfd_link_hash_warning)
8045         h = (struct elf_link_hash_entry *) h->root.u.i.link;
8046
8047       if (h->root.type != bfd_link_hash_defined
8048           && h->root.type != bfd_link_hash_defweak)
8049         /* This appears to be a reference to an undefined
8050            symbol.  Just ignore it--it will be caught by the
8051            regular reloc processing.  */
8052         return 0;
8053
8054       if (h->root.u.def.section->flags & SEC_MERGE)
8055         {
8056           sym_sec = h->root.u.def.section;
8057           symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8058                                                (sym_sec)->sec_info, h->root.u.def.value);
8059           symval = symval + sym_sec->output_section->vma
8060                    + sym_sec->output_offset;
8061         }
8062       else
8063         symval = (h->root.u.def.value
8064                   + h->root.u.def.section->output_section->vma
8065                   + h->root.u.def.section->output_offset);
8066       addend = irel->r_addend;
8067     }
8068
8069   foff = symval + addend;
8070
8071   return foff;
8072 }
8073
8074 static bfd_vma
8075 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
8076                               Elf_Internal_Rela *irel,
8077                               Elf_Internal_Shdr *symtab_hdr)
8078 {
8079   int symndx;
8080   bfd_vma *local_got_offsets;
8081   /* Get the value of the symbol referred to by the reloc.  */
8082   struct elf_link_hash_entry *h;
8083   struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
8084
8085   /* An external symbol.  */
8086   symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8087   h = elf_sym_hashes (abfd)[symndx];
8088   while (h->root.type == bfd_link_hash_indirect
8089          || h->root.type == bfd_link_hash_warning)
8090     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8091
8092   if (symndx >= 0)
8093     {
8094       BFD_ASSERT (h != NULL);
8095       return htab->sgot->output_section->vma + htab->sgot->output_offset
8096              + h->got.offset;
8097     }
8098   else
8099     {
8100       local_got_offsets = elf_local_got_offsets (abfd);
8101       BFD_ASSERT (local_got_offsets != NULL);
8102       return htab->sgot->output_section->vma + htab->sgot->output_offset
8103              + local_got_offsets[ELF32_R_SYM (irel->r_info)];
8104     }
8105
8106   /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?).  */
8107   /* The check of h->root.type is passed.  */
8108 }
8109
8110 static int
8111 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8112               asection *sec, Elf_Internal_Rela *rel)
8113 {
8114   bfd_byte *contents;
8115   unsigned short insn16;
8116
8117   if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8118     return FALSE;
8119   contents = elf_section_data (sec)->this_hdr.contents;
8120   insn16 = bfd_getb16 (contents + rel->r_offset);
8121   if (insn16 == NDS32_NOP16)
8122     return TRUE;
8123   return FALSE;
8124 }
8125
8126 /* It checks whether the instruction could be converted to
8127    16-bit form and returns the converted one.
8128
8129    `internal_relocs' is supposed to be sorted.  */
8130
8131 static int
8132 is_convert_32_to_16 (bfd *abfd, asection *sec,
8133                      Elf_Internal_Rela *reloc,
8134                      Elf_Internal_Rela *internal_relocs,
8135                      Elf_Internal_Rela *irelend,
8136                      uint16_t *insn16)
8137 {
8138 #define NORMAL_32_TO_16 (1 << 0)
8139 #define SPECIAL_32_TO_16 (1 << 1)
8140   bfd_byte *contents = NULL;
8141   bfd_signed_vma off;
8142   bfd_vma mem_addr;
8143   uint32_t insn = 0;
8144   Elf_Internal_Rela *pc_rel;
8145   int pic_ext_target = 0;
8146   Elf_Internal_Shdr *symtab_hdr;
8147   Elf_Internal_Sym *isymbuf = NULL;
8148   int convert_type;
8149   bfd_vma offset;
8150
8151   if (reloc->r_offset + 4 > sec->size)
8152     return FALSE;
8153
8154   offset = reloc->r_offset;
8155
8156   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8157     return FALSE;
8158   insn = bfd_getb32 (contents + offset);
8159
8160   if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8161     convert_type = NORMAL_32_TO_16;
8162   else if (special_convert_32_to_16 (insn, insn16, reloc))
8163     convert_type = SPECIAL_32_TO_16;
8164   else
8165     return FALSE;
8166
8167   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8168   if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8169     return FALSE;
8170
8171   /* Find the first relocation of the same relocation-type,
8172      so we iteratie them forward.  */
8173   pc_rel = reloc;
8174   while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8175     pc_rel--;
8176
8177   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8178     {
8179       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8180           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8181           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8182           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8183         {
8184           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8185                                   &pic_ext_target);
8186           if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8187               || off == 0)
8188             return FALSE;
8189           break;
8190         }
8191       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8192         {
8193           /* movi => movi55  */
8194           mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8195                                                symtab_hdr);
8196           /* mem_addr is unsigned, but the value should
8197              be between [-16, 15].  */
8198           if ((mem_addr + 0x10) >> 5)
8199             return FALSE;
8200           break;
8201         }
8202       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8203                || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8204         {
8205           /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8206              because it can be relaxed to addi for TLS_LE_ADD.  */
8207           return FALSE;
8208         }
8209       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8210                 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8211                && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8212                && convert_type == SPECIAL_32_TO_16)
8213         {
8214           /* fp-as-gp
8215              We've selected a best fp-base for this access, so we can
8216              always resolve it anyway.  Do nothing.  */
8217           break;
8218         }
8219       else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8220                 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8221                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8222                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8223                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8224                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8225         {
8226           /* Prevent unresolved addi instruction translate
8227              to addi45 or addi333.  */
8228           return FALSE;
8229         }
8230       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8231         {
8232           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8233                                   &pic_ext_target);
8234           if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8235             return FALSE;
8236           break;
8237         }
8238     }
8239
8240   return TRUE;
8241 }
8242
8243 static void
8244 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8245                     Elf_Internal_Rela *reloc,
8246                     Elf_Internal_Rela *internal_relocs,
8247                     Elf_Internal_Rela *irelend,
8248                     unsigned short insn16)
8249 {
8250   Elf_Internal_Rela *pc_rel;
8251   bfd_vma offset;
8252
8253   offset = reloc->r_offset;
8254   bfd_putb16 (insn16, contents + offset);
8255   /* Find the first relocation of the same relocation-type,
8256      so we iteratie them forward.  */
8257   pc_rel = reloc;
8258   while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8259     pc_rel--;
8260
8261   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8262     {
8263       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8264           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8265           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8266         {
8267           pc_rel->r_info =
8268             ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8269         }
8270       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8271         pc_rel->r_info =
8272           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8273       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8274         pc_rel->r_info =
8275           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8276       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8277                || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8278         pc_rel->r_info =
8279           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8280       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8281         pc_rel->r_info =
8282           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8283     }
8284 }
8285
8286 /* Find a relocation of type specified by `reloc_type'
8287    of the same r_offset with reloc.
8288    If not found, return irelend.
8289
8290    Assuming relocations are sorted by r_offset,
8291    we find the relocation from `reloc' backward untill relocs,
8292    or find it from `reloc' forward untill irelend.  */
8293
8294 static Elf_Internal_Rela *
8295 find_relocs_at_address (Elf_Internal_Rela *reloc,
8296                         Elf_Internal_Rela *relocs,
8297                         Elf_Internal_Rela *irelend,
8298                         enum elf_nds32_reloc_type reloc_type)
8299 {
8300   Elf_Internal_Rela *rel_t;
8301
8302   /* Find backward.  */
8303   for (rel_t = reloc;
8304        rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8305        rel_t--)
8306     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8307       return rel_t;
8308
8309   /* We didn't find it backward.  Try find it forward.  */
8310   for (rel_t = reloc;
8311        rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8312        rel_t++)
8313     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8314       return rel_t;
8315
8316   return irelend;
8317 }
8318
8319 /* Find a relocation of specified type and offset.
8320    `reloc' is just a refence point to find a relocation at specified offset.
8321    If not found, return irelend.
8322
8323    Assuming relocations are sorted by r_offset,
8324    we find the relocation from `reloc' backward untill relocs,
8325    or find it from `reloc' forward untill irelend.  */
8326
8327 static Elf_Internal_Rela *
8328 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8329                              Elf_Internal_Rela *relocs,
8330                              Elf_Internal_Rela *irelend,
8331                              unsigned char reloc_type,
8332                              bfd_vma offset_p)
8333 {
8334   Elf_Internal_Rela *rel_t = NULL;
8335
8336   /* First, we try to find a relocation of offset `offset_p',
8337      and then we use find_relocs_at_address to find specific type.  */
8338
8339   if (reloc->r_offset > offset_p)
8340     {
8341       /* Find backward.  */
8342       for (rel_t = reloc;
8343            rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8344         /* Do nothing.  */;
8345     }
8346   else if (reloc->r_offset < offset_p)
8347     {
8348       /* Find forward.  */
8349       for (rel_t = reloc;
8350            rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8351         /* Do nothing.  */;
8352     }
8353   else
8354     rel_t = reloc;
8355
8356   /* Not found?  */
8357   if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8358     return irelend;
8359
8360   return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8361 }
8362
8363 static bfd_boolean
8364 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8365                             Elf_Internal_Rela *internal_relocs,
8366                             Elf_Internal_Rela *irelend,
8367                             unsigned char reloc_type)
8368 {
8369   Elf_Internal_Rela *rel_t;
8370
8371   for (rel_t = reloc;
8372        rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8373        rel_t--)
8374     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8375       {
8376         if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8377             && rel_t->r_addend == reloc->r_addend)
8378           continue;
8379         return TRUE;
8380       }
8381
8382   for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8383        rel_t++)
8384     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8385       {
8386         if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8387             && rel_t->r_addend == reloc->r_addend)
8388           continue;
8389         return TRUE;
8390       }
8391
8392   return FALSE;
8393 }
8394
8395 typedef struct nds32_elf_blank nds32_elf_blank_t;
8396 struct nds32_elf_blank
8397 {
8398   /* Where the blank begins.  */
8399   bfd_vma offset;
8400   /* The size of the blank.  */
8401   bfd_vma size;
8402   /* The accumulative size before this blank.  */
8403   bfd_vma total_size;
8404   nds32_elf_blank_t *next;
8405   nds32_elf_blank_t *prev;
8406 };
8407
8408 static nds32_elf_blank_t *blank_free_list = NULL;
8409
8410 static nds32_elf_blank_t *
8411 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8412 {
8413   nds32_elf_blank_t *blank_t;
8414
8415   if (blank_free_list)
8416     {
8417       blank_t = blank_free_list;
8418       blank_free_list = blank_free_list->next;
8419     }
8420   else
8421     blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8422
8423   if (blank_t == NULL)
8424     return NULL;
8425
8426   blank_t->offset = offset_p;
8427   blank_t->size = size_p;
8428   blank_t->total_size = 0;
8429   blank_t->next = NULL;
8430   blank_t->prev = NULL;
8431
8432   return blank_t;
8433 }
8434
8435 static void
8436 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8437 {
8438   if (blank_free_list)
8439     {
8440       blank_free_list->prev = blank_p;
8441       blank_p->next = blank_free_list;
8442     }
8443   else
8444     blank_p->next = NULL;
8445
8446   blank_p->prev = NULL;
8447   blank_free_list = blank_p;
8448 }
8449
8450 static void
8451 clean_nds32_elf_blank (void)
8452 {
8453   nds32_elf_blank_t *blank_t;
8454
8455   while (blank_free_list)
8456     {
8457       blank_t = blank_free_list;
8458       blank_free_list = blank_free_list->next;
8459       free (blank_t);
8460     }
8461 }
8462
8463 static nds32_elf_blank_t *
8464 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8465 {
8466   nds32_elf_blank_t *blank_t;
8467
8468   if (!blank_p)
8469     return NULL;
8470   blank_t = blank_p;
8471
8472   while (blank_t && addr < blank_t->offset)
8473     blank_t = blank_t->prev;
8474   while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8475     blank_t = blank_t->next;
8476
8477   return blank_t;
8478 }
8479
8480 static bfd_vma
8481 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8482                            int overwrite)
8483 {
8484   nds32_elf_blank_t *blank_t;
8485
8486   blank_t = search_nds32_elf_blank (*blank_p, addr);
8487   if (!blank_t)
8488     return 0;
8489
8490   if (overwrite)
8491     *blank_p = blank_t;
8492
8493   if (addr < blank_t->offset + blank_t->size)
8494     return blank_t->total_size + (addr - blank_t->offset);
8495   else
8496     return blank_t->total_size + blank_t->size;
8497 }
8498
8499 static bfd_boolean
8500 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8501 {
8502   nds32_elf_blank_t *blank_t, *blank_t2;
8503
8504   if (!*blank_p)
8505     {
8506       *blank_p = create_nds32_elf_blank (addr, len);
8507       return *blank_p ? TRUE : FALSE;
8508     }
8509
8510   blank_t = search_nds32_elf_blank (*blank_p, addr);
8511
8512   if (blank_t == NULL)
8513     {
8514       blank_t = create_nds32_elf_blank (addr, len);
8515       if (!blank_t)
8516         return FALSE;
8517       while ((*blank_p)->prev != NULL)
8518         *blank_p = (*blank_p)->prev;
8519       blank_t->next = *blank_p;
8520       (*blank_p)->prev = blank_t;
8521       (*blank_p) = blank_t;
8522       return TRUE;
8523     }
8524
8525   if (addr < blank_t->offset + blank_t->size)
8526     {
8527       if (addr > blank_t->offset + blank_t->size)
8528         blank_t->size = addr - blank_t->offset;
8529     }
8530   else
8531     {
8532       blank_t2 = create_nds32_elf_blank (addr, len);
8533       if (!blank_t2)
8534         return FALSE;
8535       if (blank_t->next)
8536         {
8537           blank_t->next->prev = blank_t2;
8538           blank_t2->next = blank_t->next;
8539         }
8540       blank_t2->prev = blank_t;
8541       blank_t->next = blank_t2;
8542       *blank_p = blank_t2;
8543     }
8544
8545   return TRUE;
8546 }
8547
8548 static bfd_boolean
8549 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8550                                      bfd_vma len)
8551 {
8552   nds32_elf_blank_t *blank_t;
8553
8554   if (!insert_nds32_elf_blank (blank_p, addr, len))
8555     return FALSE;
8556
8557   blank_t = *blank_p;
8558
8559   if (!blank_t->prev)
8560     {
8561       blank_t->total_size = 0;
8562       blank_t = blank_t->next;
8563     }
8564
8565   while (blank_t)
8566     {
8567       blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8568       blank_t = blank_t->next;
8569     }
8570
8571   return TRUE;
8572 }
8573
8574 static void
8575 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8576 {
8577   nds32_elf_blank_t *blank_t;
8578   bfd_vma total_size = 0;
8579
8580   if (!blank_p)
8581     return;
8582
8583   blank_t = blank_p;
8584   while (blank_t->prev)
8585     blank_t = blank_t->prev;
8586   while (blank_t)
8587     {
8588       blank_t->total_size = total_size;
8589       total_size += blank_t->size;
8590       blank_t = blank_t->next;
8591     }
8592 }
8593
8594 static bfd_boolean
8595 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8596                                nds32_elf_blank_t *blank_p)
8597 {
8598   Elf_Internal_Shdr *symtab_hdr;        /* Symbol table header of this bfd.  */
8599   Elf_Internal_Sym *isym = NULL;        /* Symbol table of this bfd.  */
8600   Elf_Internal_Sym *isymend;            /* Symbol entry iterator.  */
8601   unsigned int sec_shndx;               /* The section the be relaxed.  */
8602   bfd_byte *contents;                   /* Contents data of iterating section.  */
8603   Elf_Internal_Rela *internal_relocs;
8604   Elf_Internal_Rela *irel;
8605   Elf_Internal_Rela *irelend;
8606   struct elf_link_hash_entry **sym_hashes;
8607   struct elf_link_hash_entry **end_hashes;
8608   unsigned int symcount;
8609   asection *sect;
8610   nds32_elf_blank_t *blank_t;
8611   nds32_elf_blank_t *blank_t2;
8612   nds32_elf_blank_t *blank_head;
8613
8614   blank_head = blank_t = blank_p;
8615   while (blank_head->prev != NULL)
8616     blank_head = blank_head->prev;
8617   while (blank_t->next != NULL)
8618     blank_t = blank_t->next;
8619
8620   if (blank_t->offset + blank_t->size <= sec->size)
8621     {
8622       blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8623       blank_t->next->prev = blank_t;
8624     }
8625   if (blank_head->offset > 0)
8626     {
8627       blank_head->prev = create_nds32_elf_blank (0, 0);
8628       blank_head->prev->next = blank_head;
8629       blank_head = blank_head->prev;
8630     }
8631
8632   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8633
8634   /* The deletion must stop at the next ALIGN reloc for an alignment
8635      power larger than the number of bytes we are deleting.  */
8636
8637   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8638   if (!nds32_get_local_syms (abfd, sec, &isym))
8639     return FALSE;
8640
8641   if (isym == NULL)
8642     {
8643       isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8644                                    symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8645       symtab_hdr->contents = (bfd_byte *) isym;
8646     }
8647
8648   if (isym == NULL || symtab_hdr->sh_info == 0)
8649     return FALSE;
8650
8651   blank_t = blank_head;
8652   calc_nds32_blank_total (blank_head);
8653
8654   for (sect = abfd->sections; sect != NULL; sect = sect->next)
8655     {
8656       /* Adjust all the relocs.  */
8657
8658       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
8659       internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8660                                                    TRUE /* keep_memory */);
8661       irelend = internal_relocs + sect->reloc_count;
8662
8663       blank_t = blank_head;
8664       blank_t2 = blank_head;
8665
8666       if (!(sect->flags & SEC_RELOC))
8667         continue;
8668
8669       nds32_get_section_contents (abfd, sect, &contents, TRUE);
8670
8671       for (irel = internal_relocs; irel < irelend; irel++)
8672         {
8673           bfd_vma raddr;
8674
8675           if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8676               && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8677               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8678             {
8679               unsigned long val = 0;
8680               unsigned long mask;
8681               long before, between;
8682               long offset;
8683
8684               switch (ELF32_R_TYPE (irel->r_info))
8685                 {
8686                 case R_NDS32_DIFF8:
8687                   offset = bfd_get_8 (abfd, contents + irel->r_offset);
8688                   break;
8689                 case R_NDS32_DIFF16:
8690                   offset = bfd_get_16 (abfd, contents + irel->r_offset);
8691                   break;
8692                 case R_NDS32_DIFF32:
8693                   val = bfd_get_32 (abfd, contents + irel->r_offset);
8694                   /* Get the signed bit and mask for the high part.  The
8695                      gcc will alarm when right shift 32-bit since the
8696                      type size of long may be 32-bit.  */
8697                   mask = 0 - (val >> 31);
8698                   if (mask)
8699                     offset = (val | (mask - 0xffffffff));
8700                   else
8701                     offset = val;
8702                   break;
8703                 default:
8704                   BFD_ASSERT (0);
8705                 }
8706
8707               /*                  DIFF value
8708                 0            |encoded in location|
8709                 |------------|-------------------|---------
8710                             sym+off(addend)
8711                 -- before ---| *****************
8712                 --------------------- between ---|
8713
8714                 We only care how much data are relax between DIFF,
8715                 marked as ***.  */
8716
8717               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8718               between = get_nds32_elf_blank_total (&blank_t,
8719                                                    irel->r_addend + offset, 0);
8720               if (between == before)
8721                 goto done_adjust_diff;
8722
8723               switch (ELF32_R_TYPE (irel->r_info))
8724                 {
8725                 case R_NDS32_DIFF8:
8726                   bfd_put_8 (abfd, offset - (between - before),
8727                              contents + irel->r_offset);
8728                   break;
8729                 case R_NDS32_DIFF16:
8730                   bfd_put_16 (abfd, offset - (between - before),
8731                               contents + irel->r_offset);
8732                   break;
8733                 case R_NDS32_DIFF32:
8734                   bfd_put_32 (abfd, offset - (between - before),
8735                               contents + irel->r_offset);
8736                   break;
8737                 }
8738             }
8739           else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8740               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8741             {
8742               bfd_vma val = 0;
8743               unsigned int len = 0;
8744               unsigned long before, between;
8745               bfd_byte *endp, *p;
8746
8747               val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
8748                                           &len);
8749
8750               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8751               between = get_nds32_elf_blank_total (&blank_t,
8752                                                    irel->r_addend + val, 0);
8753               if (between == before)
8754                 goto done_adjust_diff;
8755
8756               p = contents + irel->r_offset;
8757               endp = p + len -1;
8758               memset (p, 0x80, len);
8759               *(endp) = 0;
8760               p = write_uleb128 (p, val - (between - before)) - 1;
8761               if (p < endp)
8762                 *p |= 0x80;
8763             }
8764 done_adjust_diff:
8765
8766           if (sec == sect)
8767             {
8768               raddr = irel->r_offset;
8769               irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8770                                                            irel->r_offset, 1);
8771
8772               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8773                 continue;
8774               if (blank_t2 && blank_t2->next
8775                   && (blank_t2->offset > raddr
8776                       || blank_t2->next->offset <= raddr))
8777                 (*_bfd_error_handler)
8778                   (_("%B: %s\n"), abfd,
8779                    "Error: search_nds32_elf_blank reports wrong node");
8780
8781               /* Mark reloc in deleted portion as NONE.
8782                  For some relocs like R_NDS32_LABEL that doesn't modify the
8783                  content in the section.  R_NDS32_LABEL doesn't belong to the
8784                  instruction in the section, so we should preserve it.  */
8785               if (raddr >= blank_t2->offset
8786                   && raddr < blank_t2->offset + blank_t2->size
8787                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8788                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8789                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8790                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8791                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8792                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8793                 {
8794                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8795                                                R_NDS32_NONE);
8796                   continue;
8797                 }
8798             }
8799
8800           if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8801               || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8802               || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8803             continue;
8804
8805           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8806               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8807               && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8808             {
8809               if (irel->r_addend <= sec->size)
8810                 irel->r_addend -=
8811                   get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8812             }
8813         }
8814     }
8815
8816   /* Adjust the local symbols defined in this section.  */
8817   blank_t = blank_head;
8818   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8819     {
8820       if (isym->st_shndx == sec_shndx)
8821         {
8822           if (isym->st_value <= sec->size)
8823             {
8824               bfd_vma ahead;
8825               bfd_vma orig_addr = isym->st_value;
8826
8827               ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8828               isym->st_value -= ahead;
8829
8830               /* Adjust function size.  */
8831               if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8832                   && isym->st_size > 0)
8833                 isym->st_size -=
8834                   get_nds32_elf_blank_total
8835                   (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8836             }
8837         }
8838     }
8839
8840   /* Now adjust the global symbols defined in this section.  */
8841   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8842               - symtab_hdr->sh_info);
8843   sym_hashes = elf_sym_hashes (abfd);
8844   end_hashes = sym_hashes + symcount;
8845   blank_t = blank_head;
8846   for (; sym_hashes < end_hashes; sym_hashes++)
8847     {
8848       struct elf_link_hash_entry *sym_hash = *sym_hashes;
8849
8850       if ((sym_hash->root.type == bfd_link_hash_defined
8851            || sym_hash->root.type == bfd_link_hash_defweak)
8852           && sym_hash->root.u.def.section == sec)
8853         {
8854           if (sym_hash->root.u.def.value <= sec->size)
8855             {
8856               bfd_vma ahead;
8857               bfd_vma orig_addr = sym_hash->root.u.def.value;
8858
8859               ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8860               sym_hash->root.u.def.value -= ahead;
8861
8862               /* Adjust function size.  */
8863               if (sym_hash->type == STT_FUNC)
8864                 sym_hash->size -=
8865                   get_nds32_elf_blank_total
8866                   (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8867
8868             }
8869         }
8870     }
8871
8872   contents = elf_section_data (sec)->this_hdr.contents;
8873   blank_t = blank_head;
8874   while (blank_t->next)
8875     {
8876       /* Actually delete the bytes.  */
8877
8878       /* If current blank is the last blank overlap with current section,
8879          go to finish process.  */
8880       if (sec->size <= (blank_t->next->offset))
8881         break;
8882
8883       memmove (contents + blank_t->offset - blank_t->total_size,
8884                contents + blank_t->offset + blank_t->size,
8885                blank_t->next->offset - (blank_t->offset + blank_t->size));
8886
8887       blank_t = blank_t->next;
8888     }
8889
8890   if (sec->size > (blank_t->offset + blank_t->size))
8891     {
8892       /* There are remaining code between blank and section boundary.
8893          Move the remaining code to appropriate location.  */
8894       memmove (contents + blank_t->offset - blank_t->total_size,
8895                contents + blank_t->offset + blank_t->size,
8896                sec->size - (blank_t->offset + blank_t->size));
8897       sec->size -= blank_t->total_size + blank_t->size;
8898     }
8899   else
8900     /* This blank is not entirely included in the section,
8901        reduce the section size by only part of the blank size.  */
8902     sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8903
8904   while (blank_head)
8905     {
8906       blank_t = blank_head;
8907       blank_head = blank_head->next;
8908       remove_nds32_elf_blank (blank_t);
8909     }
8910
8911   return TRUE;
8912 }
8913
8914 /* Get the contents of a section.  */
8915
8916 static int
8917 nds32_get_section_contents (bfd *abfd, asection *sec,
8918                             bfd_byte **contents_p, bfd_boolean cache)
8919 {
8920   /* Get the section contents.  */
8921   if (elf_section_data (sec)->this_hdr.contents != NULL)
8922     *contents_p = elf_section_data (sec)->this_hdr.contents;
8923   else
8924     {
8925       if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8926         return FALSE;
8927       if (cache)
8928         elf_section_data (sec)->this_hdr.contents = *contents_p;
8929     }
8930
8931   return TRUE;
8932 }
8933
8934 /* Get the contents of the internal symbol of abfd.  */
8935
8936 static int
8937 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8938                       Elf_Internal_Sym **isymbuf_p)
8939 {
8940   Elf_Internal_Shdr *symtab_hdr;
8941   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8942
8943   /* Read this BFD's local symbols if we haven't done so already.  */
8944   if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8945     {
8946       *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8947       if (*isymbuf_p == NULL)
8948         {
8949           *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8950                                              symtab_hdr->sh_info, 0,
8951                                              NULL, NULL, NULL);
8952           if (*isymbuf_p == NULL)
8953             return FALSE;
8954         }
8955     }
8956   symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8957
8958   return TRUE;
8959 }
8960
8961 /* Range of small data.  */
8962 static bfd_vma sdata_range[2][2];
8963 static bfd_vma const sdata_init_range[2] =
8964 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8965
8966 static int
8967 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8968                      bfd_byte *contents, bfd_vma addr)
8969 {
8970   unsigned long insn = bfd_getb32 (contents + addr);
8971
8972   if (insn & 0x80000000)
8973     return 2;
8974
8975   return 4;
8976 }
8977
8978 /* Set the gp relax range.  We have to measure the safe range
8979    to do gp relaxation.  */
8980
8981 static void
8982 relax_range_measurement (bfd *abfd)
8983 {
8984   asection *sec_f, *sec_b;
8985   /* For upper bound.   */
8986   bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8987   bfd_vma align;
8988   static int decide_relax_range = 0;
8989   int i;
8990   int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8991
8992   if (decide_relax_range)
8993     return;
8994   decide_relax_range = 1;
8995
8996   if (sda_rela_sec == NULL)
8997     {
8998       /* Since there is no data sections, we assume the range is page size.  */
8999       for (i = 0; i < range_number; i++)
9000         {
9001           sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9002           sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9003         }
9004       return;
9005     }
9006
9007   /* Get the biggest alignment power after the gp located section.  */
9008   sec_f = sda_rela_sec->output_section;
9009   sec_b = sec_f->next;
9010   align = 0;
9011   while (sec_b != NULL)
9012     {
9013       if ((unsigned)(1 << sec_b->alignment_power) > align)
9014         align = (1 << sec_b->alignment_power);
9015       sec_b = sec_b->next;
9016     }
9017
9018   /* I guess we can not determine the section before
9019      gp located section, so we assume the align is max page size.  */
9020   for (i = 0; i < range_number; i++)
9021     {
9022       sdata_range[i][1] = sdata_init_range[i] - align;
9023       BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9024       sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9025       BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9026     }
9027 }
9028
9029 /* These are macros used to check flags encoded in r_addend.
9030    They are only used by nds32_elf_relax_section ().  */
9031 #define GET_SEQ_LEN(addend)     ((addend) & 0x000000ff)
9032 #define IS_1ST_CONVERT(addend)  ((addend) & 0x80000000)
9033 #define IS_OPTIMIZE(addend)     ((addend) & 0x40000000)
9034 #define IS_16BIT_ON(addend)     ((addend) & 0x20000000)
9035
9036 /* Relax LONGCALL1 relocation for nds32_elf_relax_section.  */
9037
9038 static bfd_boolean
9039 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9040                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9041                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9042                            Elf_Internal_Shdr *symtab_hdr)
9043 {
9044   /* There are 3 variations for LONGCALL1
9045      case 4-4-2; 16-bit on, optimize off or optimize for space
9046      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9047      ori   ta, ta, lo12(symbol) ; LO12S0
9048      jral5 ta                   ;
9049
9050      case 4-4-4; 16-bit off, optimize don't care
9051      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9052      ori   ta, ta, lo12(symbol) ; LO12S0
9053      jral  ta                   ;
9054
9055      case 4-4-4; 16-bit on, optimize for speed
9056      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9057      ori   ta, ta, lo12(symbol) ; LO12S0
9058      jral  ta                   ;
9059      Check code for -mlong-calls output.  */
9060
9061   /* Get the reloc for the address from which the register is
9062      being loaded.  This reloc will tell us which function is
9063      actually being called.  */
9064
9065   bfd_vma laddr;
9066   int seq_len;  /* Original length of instruction sequence.  */
9067   uint32_t insn;
9068   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9069   int pic_ext_target = 0;
9070   bfd_signed_vma foff;
9071   uint16_t insn16;
9072
9073   irelend = internal_relocs + sec->reloc_count;
9074   seq_len = GET_SEQ_LEN (irel->r_addend);
9075   laddr = irel->r_offset;
9076   *insn_len = seq_len;
9077
9078   hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9079                                            R_NDS32_HI20_RELA, laddr);
9080   lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9081                                            R_NDS32_LO12S0_ORI_RELA,
9082                                            laddr + 4);
9083
9084   if (hi_irelfn == irelend || lo_irelfn == irelend)
9085     {
9086       (*_bfd_error_handler)
9087         ("%B: warning: R_NDS32_LONGCALL1 points to unrecognized"
9088          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9089       return FALSE;
9090     }
9091
9092   /* Get the value of the symbol referred to by the reloc.  */
9093   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9094                            &pic_ext_target);
9095
9096   /* This condition only happened when symbol is undefined.  */
9097   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9098       || foff >= CONSERVATIVE_24BIT_S1)
9099     return FALSE;
9100
9101   /* Relax to: jal symbol; 25_PCREL */
9102   /* For simplicity of coding, we are going to modify the section
9103      contents, the section relocs, and the BFD symbol table.  We
9104      must tell the rest of the code not to free up this
9105      information.  It would be possible to instead create a table
9106      of changes which have to be made, as is done in coff-mips.c;
9107      that would be more work, but would require less memory when
9108      the linker is run.  */
9109
9110   /* Replace the long call with a jal.  */
9111   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9112                                R_NDS32_25_PCREL_RELA);
9113   irel->r_addend = hi_irelfn->r_addend;
9114
9115   /* We don't resolve this here but resolve it in relocate_section.  */
9116   insn = INSN_JAL;
9117   bfd_putb32 (insn, contents + irel->r_offset);
9118
9119   hi_irelfn->r_info =
9120     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9121   lo_irelfn->r_info =
9122     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9123   *insn_len = 4;
9124
9125   if (seq_len & 0x2)
9126     {
9127       insn16 = NDS32_NOP16;
9128       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9129       lo_irelfn->r_info =
9130         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9131       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9132       *insn_len += 2;
9133     }
9134   return TRUE;
9135 }
9136
9137 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9138 /* Relax LONGCALL2 relocation for nds32_elf_relax_section.  */
9139
9140 static bfd_boolean
9141 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9142                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9143                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9144                            Elf_Internal_Shdr *symtab_hdr)
9145 {
9146   /* bltz  rt, .L1   ; LONGCALL2
9147      jal   symbol   ; 25_PCREL
9148      .L1: */
9149
9150   /* Get the reloc for the address from which the register is
9151      being loaded.  This reloc will tell us which function is
9152      actually being called.  */
9153
9154   bfd_vma laddr;
9155   uint32_t insn;
9156   Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9157   int pic_ext_target = 0;
9158   bfd_signed_vma foff;
9159
9160   irelend = internal_relocs + sec->reloc_count;
9161   laddr = irel->r_offset;
9162   i1_irelfn =
9163     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9164                                  R_NDS32_25_PCREL_RELA, laddr + 4);
9165
9166   if (i1_irelfn == irelend)
9167     {
9168       (*_bfd_error_handler)
9169         ("%B: warning: R_NDS32_LONGCALL2 points to unrecognized"
9170          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9171       return FALSE;
9172     }
9173
9174   insn = bfd_getb32 (contents + laddr);
9175
9176   /* Get the value of the symbol referred to by the reloc.  */
9177   foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
9178                            &pic_ext_target);
9179
9180   if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9181       || foff >= CONSERVATIVE_16BIT_S1)
9182     return FALSE;
9183
9184   /* Relax to   bgezal   rt, label ; 17_PCREL
9185      or         bltzal   rt, label ; 17_PCREL */
9186
9187   /* Convert to complimentary conditional call.  */
9188   insn = CONVERT_CONDITION_CALL (insn);
9189
9190   /* For simplicity of coding, we are going to modify the section
9191      contents, the section relocs, and the BFD symbol table.  We
9192      must tell the rest of the code not to free up this
9193      information.  It would be possible to instead create a table
9194      of changes which have to be made, as is done in coff-mips.c;
9195      that would be more work, but would require less memory when
9196      the linker is run.  */
9197
9198   /* Clean unnessary relocations.  */
9199   i1_irelfn->r_info =
9200     ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9201   cond_irelfn =
9202     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9203                                  R_NDS32_17_PCREL_RELA, laddr);
9204   if (cond_irelfn != irelend)
9205     cond_irelfn->r_info =
9206       ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9207
9208   /* Replace the long call with a bgezal.  */
9209   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9210                                R_NDS32_17_PCREL_RELA);
9211   irel->r_addend = i1_irelfn->r_addend;
9212
9213   bfd_putb32 (insn, contents + irel->r_offset);
9214
9215   *insn_len = 4;
9216   return TRUE;
9217 }
9218
9219 /* Relax LONGCALL3 relocation for nds32_elf_relax_section.  */
9220
9221 static bfd_boolean
9222 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9223                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9224                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9225                            Elf_Internal_Shdr *symtab_hdr)
9226 {
9227   /* There are 3 variations for LONGCALL3
9228      case 4-4-4-2; 16-bit on, optimize off or optimize for space
9229      bltz  rt,   $1                ; LONGCALL3
9230      sethi ta,   hi20(symbol)      ; HI20
9231      ori   ta, ta,  lo12(symbol)   ; LO12S0
9232      jral5 ta                      ;
9233      $1
9234
9235      case 4-4-4-4; 16-bit off, optimize don't care
9236      bltz  rt,   $1                ; LONGCALL3
9237      sethi ta,   hi20(symbol)      ; HI20
9238      ori   ta, ta,  lo12(symbol)   ; LO12S0
9239      jral  ta                      ;
9240      $1
9241
9242      case 4-4-4-4; 16-bit on, optimize for speed
9243      bltz  rt,   $1                ; LONGCALL3
9244      sethi ta,   hi20(symbol)      ; HI20
9245      ori   ta, ta,  lo12(symbol)   ; LO12S0
9246      jral  ta                      ;
9247      $1 */
9248
9249   /* Get the reloc for the address from which the register is
9250      being loaded.  This reloc will tell us which function is
9251      actually being called.  */
9252
9253   bfd_vma laddr;
9254   int seq_len;  /* Original length of instruction sequence.  */
9255   uint32_t insn;
9256   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9257   int pic_ext_target = 0;
9258   bfd_signed_vma foff;
9259   uint16_t insn16;
9260
9261   irelend = internal_relocs + sec->reloc_count;
9262   seq_len = GET_SEQ_LEN (irel->r_addend);
9263   laddr = irel->r_offset;
9264   *insn_len = seq_len;
9265
9266   hi_irelfn =
9267     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9268                                  R_NDS32_HI20_RELA, laddr + 4);
9269   lo_irelfn =
9270     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9271                                  R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9272
9273   if (hi_irelfn == irelend || lo_irelfn == irelend)
9274     {
9275       (*_bfd_error_handler)
9276         ("%B: warning: R_NDS32_LONGCALL3 points to unrecognized"
9277          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9278       return FALSE;
9279     }
9280
9281   /* Get the value of the symbol referred to by the reloc.  */
9282   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9283                            &pic_ext_target);
9284
9285   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9286       || foff >= CONSERVATIVE_24BIT_S1)
9287     return FALSE;
9288
9289   insn = bfd_getb32 (contents + laddr);
9290   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9291     {
9292       /* Relax to  bgezal   rt, label ; 17_PCREL
9293          or        bltzal   rt, label ; 17_PCREL */
9294
9295       /* Convert to complimentary conditional call.  */
9296       insn = CONVERT_CONDITION_CALL (insn);
9297       bfd_putb32 (insn, contents + irel->r_offset);
9298
9299       *insn_len = 4;
9300       irel->r_info =
9301         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9302       hi_irelfn->r_info =
9303         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9304       lo_irelfn->r_info =
9305         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9306
9307       cond_irelfn =
9308         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9309                                      R_NDS32_17_PCREL_RELA, laddr);
9310       if (cond_irelfn != irelend)
9311         {
9312           cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9313                                               R_NDS32_17_PCREL_RELA);
9314           cond_irelfn->r_addend = hi_irelfn->r_addend;
9315         }
9316
9317       if (seq_len & 0x2)
9318         {
9319           insn16 = NDS32_NOP16;
9320           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9321           hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9322                                             R_NDS32_INSN16);
9323           hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9324           insn_len += 2;
9325         }
9326     }
9327   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9328     {
9329       /* Relax to the following instruction sequence
9330          bltz  rt,   $1 ; LONGCALL2
9331          jal   symbol   ; 25_PCREL
9332          $1     */
9333       *insn_len = 8;
9334       insn = INSN_JAL;
9335       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9336
9337       hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9338                                         R_NDS32_25_PCREL_RELA);
9339       irel->r_info =
9340         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9341
9342       lo_irelfn->r_info =
9343         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9344
9345       if (seq_len & 0x2)
9346         {
9347           insn16 = NDS32_NOP16;
9348           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9349           lo_irelfn->r_info =
9350             ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9351           lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9352           insn_len += 2;
9353         }
9354     }
9355   return TRUE;
9356 }
9357
9358 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section.  */
9359
9360 static bfd_boolean
9361 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9362                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9363                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9364                            Elf_Internal_Shdr *symtab_hdr)
9365 {
9366   /* There are 3 variations for LONGJUMP1
9367      case 4-4-2; 16-bit bit on, optimize off or optimize for space
9368      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9369      ori   ta, ta, lo12(symbol)  ; LO12S0
9370      jr5   ta                    ;
9371
9372      case 4-4-4; 16-bit off, optimize don't care
9373      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9374      ori   ta, ta, lo12(symbol)  ; LO12S0
9375      jr    ta                    ;
9376
9377      case 4-4-4; 16-bit on, optimize for speed
9378      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
9379      ori   ta, ta, lo12(symbol)  ; LO12S0
9380      jr    ta                    ;      */
9381
9382   /* Get the reloc for the address from which the register is
9383      being loaded.  This reloc will tell us which function is
9384      actually being called.  */
9385
9386   bfd_vma laddr;
9387   int seq_len;  /* Original length of instruction sequence.  */
9388   int insn16_on;        /* 16-bit on/off.  */
9389   uint32_t insn;
9390   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9391   int pic_ext_target = 0;
9392   bfd_signed_vma foff;
9393   uint16_t insn16;
9394   unsigned long reloc;
9395
9396   irelend = internal_relocs + sec->reloc_count;
9397   seq_len = GET_SEQ_LEN (irel->r_addend);
9398   laddr = irel->r_offset;
9399   *insn_len = seq_len;
9400   insn16_on = IS_16BIT_ON (irel->r_addend);
9401
9402   hi_irelfn =
9403     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9404                                  R_NDS32_HI20_RELA, laddr);
9405   lo_irelfn =
9406     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9407                                  R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9408   if (hi_irelfn == irelend || lo_irelfn == irelend)
9409     {
9410       (*_bfd_error_handler)
9411         ("%B: warning: R_NDS32_LONGJUMP1 points to unrecognized"
9412          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9413       return FALSE;
9414     }
9415
9416   /* Get the value of the symbol referred to by the reloc.  */
9417   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9418                            &pic_ext_target);
9419
9420   if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9421       || foff < -CONSERVATIVE_24BIT_S1)
9422     return FALSE;
9423
9424   if (insn16_on && foff >= -ACCURATE_8BIT_S1
9425       && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9426     {
9427       /* j8     label */
9428       /* 16-bit on, but not optimized for speed.  */
9429       reloc = R_NDS32_9_PCREL_RELA;
9430       insn16 = INSN_J8;
9431       bfd_putb16 (insn16, contents + irel->r_offset);
9432       *insn_len = 2;
9433       irel->r_info =
9434         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9435     }
9436   else
9437     {
9438       /* j     label */
9439       reloc = R_NDS32_25_PCREL_RELA;
9440       insn = INSN_J;
9441       bfd_putb32 (insn, contents + irel->r_offset);
9442       *insn_len = 4;
9443       irel->r_info =
9444         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9445       irel->r_addend = 0;
9446     }
9447
9448   hi_irelfn->r_info =
9449     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9450   lo_irelfn->r_info =
9451     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9452
9453   if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9454     {
9455       insn16 = NDS32_NOP16;
9456       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9457       lo_irelfn->r_info =
9458         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9459                       R_NDS32_INSN16);
9460       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9461       *insn_len += 2;
9462     }
9463   return TRUE;
9464 }
9465
9466 /* Revert condition branch.  This function does not check if the input
9467    instruction is condition branch or not.  */
9468
9469 static void
9470 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9471                            uint16_t *re_insn16, uint32_t *re_insn)
9472 {
9473   uint32_t comp_insn = 0;
9474   uint16_t comp_insn16 = 0;
9475
9476   if (insn)
9477     {
9478       if (N32_OP6 (insn) == N32_OP6_BR1)
9479         {
9480           /* beqs label.  */
9481           comp_insn = (insn ^ 0x4000) & 0xffffc000;
9482           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9483             {
9484               /* Insn can be contracted to 16-bit implied r5.  */
9485               comp_insn16 =
9486                 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9487               comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9488             }
9489         }
9490       else if (N32_OP6 (insn) == N32_OP6_BR3)
9491         {
9492           /* bnec $ta, imm11, label.  */
9493           comp_insn = (insn ^ 0x80000) & 0xffffff00;
9494         }
9495       else
9496         {
9497           comp_insn = (insn ^ 0x10000) & 0xffffc000;
9498           if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9499               || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9500             {
9501               if (N32_IS_RT3 (insn))
9502                 {
9503                   /* Insn can be contracted to 16-bit.  */
9504                   comp_insn16 =
9505                     (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9506                   comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9507                 }
9508               else if (N32_RT5 (insn) == REG_R15)
9509                 {
9510                   /* Insn can be contracted to 16-bit.  */
9511                   comp_insn16 =
9512                     (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9513                 }
9514             }
9515         }
9516     }
9517   else
9518     {
9519       switch ((insn16 & 0xf000) >> 12)
9520         {
9521         case 0xc:
9522           /* beqz38 or bnez38 */
9523           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9524           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9525           comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9526           break;
9527
9528         case 0xd:
9529           /* beqs38 or bnes38 */
9530           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9531           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9532           comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9533             | (REG_R5 << 15);
9534           break;
9535
9536         case 0xe:
9537           /* beqzS8 or bnezS8 */
9538           comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9539           comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9540           comp_insn |= REG_R15 << 20;
9541           break;
9542
9543         default:
9544           break;
9545         }
9546     }
9547   if (comp_insn && re_insn)
9548     *re_insn = comp_insn;
9549   if (comp_insn16 && re_insn16)
9550     *re_insn16 = comp_insn16;
9551 }
9552
9553 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section.  */
9554
9555 static bfd_boolean
9556 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9557                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9558                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9559                            Elf_Internal_Shdr *symtab_hdr)
9560 {
9561   /* There are 3 variations for LONGJUMP2
9562      case 2-4;  1st insn convertible, 16-bit on,
9563      optimize off or optimize for space
9564      bnes38  rt, ra, $1 ; LONGJUMP2
9565      j       label      ; 25_PCREL
9566      $1:
9567
9568      case 4-4; 1st insn not convertible
9569      bne  rt, ra, $1 ; LONGJUMP2
9570      j    label      ; 25_PCREL
9571      $1:
9572
9573      case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9574      bne  rt, ra, $1 ; LONGJUMP2
9575      j    label      ; 25_PCREL
9576      $1: */
9577
9578   /* Get the reloc for the address from which the register is
9579      being loaded.  This reloc will tell us which function is
9580      actually being called.  */
9581
9582   bfd_vma laddr;
9583   int seq_len;  /* Original length of instruction sequence.  */
9584   Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9585   int pic_ext_target = 0, first_size;
9586   unsigned int i;
9587   bfd_signed_vma foff;
9588   uint32_t insn, re_insn = 0;
9589   uint16_t insn16, re_insn16 = 0;
9590   unsigned long reloc, cond_reloc;
9591
9592   enum elf_nds32_reloc_type checked_types[] =
9593     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9594
9595   irelend = internal_relocs + sec->reloc_count;
9596   seq_len = GET_SEQ_LEN (irel->r_addend);
9597   laddr = irel->r_offset;
9598   *insn_len = seq_len;
9599   first_size = (seq_len == 6) ? 2 : 4;
9600
9601   i2_irelfn =
9602     find_relocs_at_address_addr (irel, internal_relocs,
9603                                  irelend, R_NDS32_25_PCREL_RELA,
9604                                  laddr + first_size);
9605
9606   for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9607     {
9608       cond_irelfn =
9609         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9610                                      checked_types[i], laddr);
9611       if (cond_irelfn != irelend)
9612         break;
9613     }
9614
9615   if (i2_irelfn == irelend || cond_irelfn == irelend)
9616     {
9617       (*_bfd_error_handler)
9618         ("%B: warning: R_NDS32_LONGJUMP2 points to unrecognized"
9619          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9620       return FALSE;
9621     }
9622
9623   /* Get the value of the symbol referred to by the reloc.  */
9624   foff =
9625     calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9626                       &pic_ext_target);
9627   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9628       || foff >= CONSERVATIVE_16BIT_S1)
9629     return FALSE;
9630
9631   /* Get the all corresponding instructions.  */
9632   if (first_size == 4)
9633     {
9634       insn = bfd_getb32 (contents + laddr);
9635       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9636     }
9637   else
9638     {
9639       insn16 = bfd_getb16 (contents + laddr);
9640       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9641     }
9642
9643   if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9644       && foff < ACCURATE_8BIT_S1 - first_size)
9645     {
9646       if (first_size == 4)
9647         {
9648           /* Don't convert it to 16-bit now, keep this as relaxable for
9649              ``label reloc; INSN16''.  */
9650
9651           /* Save comp_insn32 to buffer.  */
9652           bfd_putb32 (re_insn, contents + irel->r_offset);
9653           *insn_len = 4;
9654           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9655             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9656           cond_reloc = R_NDS32_INSN16;
9657         }
9658       else
9659         {
9660           bfd_putb16 (re_insn16, contents + irel->r_offset);
9661           *insn_len = 2;
9662           reloc = R_NDS32_9_PCREL_RELA;
9663           cond_reloc = R_NDS32_NONE;
9664         }
9665     }
9666   else if (N32_OP6 (re_insn) == N32_OP6_BR1
9667            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9668                && foff < ACCURATE_14BIT_S1 - first_size))
9669     {
9670       /* beqs     label    ; 15_PCREL */
9671       bfd_putb32 (re_insn, contents + irel->r_offset);
9672       *insn_len = 4;
9673       reloc = R_NDS32_15_PCREL_RELA;
9674       cond_reloc = R_NDS32_NONE;
9675     }
9676   else if (N32_OP6 (re_insn) == N32_OP6_BR2
9677            && foff >= -CONSERVATIVE_16BIT_S1
9678            && foff < CONSERVATIVE_16BIT_S1)
9679     {
9680       /* beqz     label ; 17_PCREL */
9681       bfd_putb32 (re_insn, contents + irel->r_offset);
9682       *insn_len = 4;
9683       reloc = R_NDS32_17_PCREL_RELA;
9684       cond_reloc = R_NDS32_NONE;
9685     }
9686   else
9687     return FALSE;
9688
9689   /* Set all relocations.  */
9690   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9691   irel->r_addend = i2_irelfn->r_addend;
9692
9693   cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9694                                       cond_reloc);
9695   cond_irelfn->r_addend = 0;
9696
9697   if ((seq_len ^ *insn_len ) & 0x2)
9698     {
9699       insn16 = NDS32_NOP16;
9700       bfd_putb16 (insn16, contents + irel->r_offset + 4);
9701       i2_irelfn->r_offset = 4;
9702       i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9703                                         R_NDS32_INSN16);
9704       i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9705       *insn_len += 2;
9706     }
9707   else
9708     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9709                                       R_NDS32_NONE);
9710   return TRUE;
9711 }
9712
9713 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section.  */
9714
9715 static bfd_boolean
9716 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9717                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9718                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9719                            Elf_Internal_Shdr *symtab_hdr)
9720 {
9721   /* There are 5 variations for LONGJUMP3
9722      case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9723      optimize off or optimize for space
9724      bnes38   rt, ra, $1            ; LONGJUMP3
9725      sethi    ta, hi20(symbol)      ; HI20
9726      ori      ta, ta, lo12(symbol)  ; LO12S0
9727      jr5      ta                    ;
9728      $1:                            ;
9729
9730      case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9731      bnes38   rt, ra, $1           ; LONGJUMP3
9732      sethi    ta, hi20(symbol)     ; HI20
9733      ori      ta, ta, lo12(symbol) ; LO12S0
9734      jr5      ta                   ;
9735      $1:                           ; LABEL
9736
9737      case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9738      optimize off or optimize for space
9739      bne   rt, ra, $1           ; LONGJUMP3
9740      sethi ta, hi20(symbol)     ; HI20
9741      ori   ta, ta, lo12(symbol) ; LO12S0
9742      jr5   ta                   ;
9743      $1:                        ;
9744
9745      case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9746      16-bit off if no INSN16
9747      bne   rt, ra, $1           ; LONGJUMP3
9748      sethi ta, hi20(symbol)     ; HI20
9749      ori   ta, ta, lo12(symbol) ; LO12S0
9750      jr    ta                   ;
9751      $1:                        ;
9752
9753      case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9754      16-bit off if no INSN16
9755      bne   rt, ra, $1           ; LONGJUMP3
9756      sethi ta, hi20(symbol)     ; HI20
9757      ori   ta, ta, lo12(symbol) ; LO12S0
9758      jr    ta                   ;
9759      $1:                        ; LABEL */
9760
9761   /* Get the reloc for the address from which the register is
9762      being loaded.  This reloc will tell us which function is
9763      actually being called.  */
9764   enum elf_nds32_reloc_type checked_types[] =
9765     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9766
9767   int reloc_off = 0, cond_removed = 0, convertible;
9768   bfd_vma laddr;
9769   int seq_len;  /* Original length of instruction sequence.  */
9770   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9771   int pic_ext_target = 0, first_size;
9772   unsigned int i;
9773   bfd_signed_vma foff;
9774   uint32_t insn, re_insn = 0;
9775   uint16_t insn16, re_insn16 = 0;
9776   unsigned long reloc, cond_reloc;
9777
9778   irelend = internal_relocs + sec->reloc_count;
9779   seq_len = GET_SEQ_LEN (irel->r_addend);
9780   laddr = irel->r_offset;
9781   *insn_len = seq_len;
9782
9783   convertible = IS_1ST_CONVERT (irel->r_addend);
9784
9785   if (convertible)
9786     first_size = 2;
9787   else
9788     first_size = 4;
9789
9790   /* Get all needed relocations.  */
9791   hi_irelfn =
9792     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9793                                  R_NDS32_HI20_RELA, laddr + first_size);
9794   lo_irelfn =
9795     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9796                                  R_NDS32_LO12S0_ORI_RELA,
9797                                  laddr + first_size + 4);
9798
9799   for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9800     {
9801       cond_irelfn =
9802         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9803                                      checked_types[i], laddr);
9804       if (cond_irelfn != irelend)
9805         break;
9806     }
9807
9808   if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9809     {
9810       (*_bfd_error_handler)
9811         ("%B: warning: R_NDS32_LONGJUMP3 points to unrecognized"
9812          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9813       return FALSE;
9814     }
9815
9816   /* Get the value of the symbol referred to by the reloc.  */
9817   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9818                            &pic_ext_target);
9819
9820   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9821       || foff >= CONSERVATIVE_24BIT_S1)
9822     return FALSE;
9823
9824   /* Get the all corresponding instructions.  */
9825   if (first_size == 4)
9826     {
9827       insn = bfd_getb32 (contents + laddr);
9828       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9829     }
9830   else
9831     {
9832       insn16 = bfd_getb16 (contents + laddr);
9833       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9834     }
9835
9836   /* For simplicity of coding, we are going to modify the section
9837      contents, the section relocs, and the BFD symbol table.  We
9838      must tell the rest of the code not to free up this
9839      information.  It would be possible to instead create a table
9840      of changes which have to be made, as is done in coff-mips.c;
9841      that would be more work, but would require less memory when
9842      the linker is run.  */
9843
9844   if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9845       && foff < ACCURATE_8BIT_S1 - first_size)
9846     {
9847       if (!(seq_len & 0x2))
9848         {
9849           /* Don't convert it to 16-bit now, keep this as relaxable
9850              for ``label reloc; INSN1a''6.  */
9851           /* Save comp_insn32 to buffer.  */
9852           bfd_putb32 (re_insn, contents + irel->r_offset);
9853           *insn_len = 4;
9854           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9855             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9856           cond_reloc = R_NDS32_INSN16;
9857         }
9858       else
9859         {
9860           /* Not optimize for speed; convert sequence to 16-bit.  */
9861           /* Save comp_insn16 to buffer.  */
9862           bfd_putb16 (re_insn16, contents + irel->r_offset);
9863           *insn_len = 2;
9864           reloc = R_NDS32_9_PCREL_RELA;
9865           cond_reloc = R_NDS32_NONE;
9866         }
9867       cond_removed = 1;
9868     }
9869   else if (N32_OP6 (re_insn) == N32_OP6_BR1
9870            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9871                && foff < ACCURATE_14BIT_S1 - first_size))
9872     {
9873       /* beqs     label    ; 15_PCREL */
9874       bfd_putb32 (re_insn, contents + irel->r_offset);
9875       *insn_len = 4;
9876       reloc = R_NDS32_15_PCREL_RELA;
9877       cond_reloc = R_NDS32_NONE;
9878       cond_removed = 1;
9879     }
9880   else if (N32_OP6 (re_insn) == N32_OP6_BR2
9881            && foff >= -CONSERVATIVE_16BIT_S1
9882            && foff < CONSERVATIVE_16BIT_S1)
9883     {
9884       /* beqz     label ; 17_PCREL */
9885       bfd_putb32 (re_insn, contents + irel->r_offset);
9886       *insn_len = 4;
9887       reloc = R_NDS32_17_PCREL_RELA;
9888       cond_reloc = R_NDS32_NONE;
9889       cond_removed = 1;
9890     }
9891   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9892            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9893     {
9894       /* Relax to one of the following 3 variations
9895
9896          case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9897          for space
9898          bnes38  rt, $1 ; LONGJUMP2
9899          j       label  ; 25_PCREL
9900          $1
9901
9902          case 4-4; 1st insn not convertible, others don't care
9903          bne   rt, ra, $1 ; LONGJUMP2
9904          j     label      ; 25_PCREL
9905          $1
9906
9907          case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9908          bne   rt, ra, $1 ; LONGJUMP2
9909          j     label      ; 25_PCREL
9910          $1 */
9911
9912       /* Offset for first instruction.  */
9913
9914       /* Use j label as second instruction.  */
9915       *insn_len = 4 + first_size;
9916       insn = INSN_J;
9917       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9918       reloc = R_NDS32_LONGJUMP2;
9919       cond_reloc = R_NDS32_25_PLTREL;
9920     }
9921     else
9922       return FALSE;
9923
9924     if (cond_removed == 1)
9925       {
9926         /* Set all relocations.  */
9927         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9928         irel->r_addend = hi_irelfn->r_addend;
9929
9930         cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9931                                             cond_reloc);
9932         cond_irelfn->r_addend = 0;
9933         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9934                                           R_NDS32_NONE);
9935       }
9936     else
9937       {
9938         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9939         irel->r_addend = irel->r_addend;
9940         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9941                                           cond_reloc);
9942       }
9943
9944   if ((seq_len ^ *insn_len ) & 0x2)
9945     {
9946       insn16 = NDS32_NOP16;
9947       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9948       lo_irelfn->r_offset = *insn_len;
9949       lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9950                                         R_NDS32_INSN16);
9951       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9952       *insn_len += 2;
9953     }
9954   else
9955     lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9956                                       R_NDS32_NONE);
9957   return TRUE;
9958 }
9959
9960 /* Relax LONGCALL4 relocation for nds32_elf_relax_section.  */
9961
9962 static bfd_boolean
9963 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9964                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9965                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9966                            Elf_Internal_Shdr *symtab_hdr)
9967 {
9968   /* The pattern for LONGCALL4.  Support for function cse.
9969      sethi ta, hi20(symbol)     ; LONGCALL4/HI20
9970      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9971      jral  ta                   ; PTR_RES/EMPTY/INSN16  */
9972
9973   bfd_vma laddr;
9974   uint32_t insn;
9975   Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9976   Elf_Internal_Rela *irelend;
9977   int pic_ext_target = 0;
9978   bfd_signed_vma foff;
9979
9980   irelend = internal_relocs + sec->reloc_count;
9981   laddr = irel->r_offset;
9982
9983   /* Get the reloc for the address from which the register is
9984      being loaded.  This reloc will tell us which function is
9985      actually being called.  */
9986   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9987                                          R_NDS32_HI20_RELA, laddr);
9988
9989   if (hi_irel == irelend)
9990     {
9991       (*_bfd_error_handler)
9992         ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
9993          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9994       return FALSE;
9995     }
9996
9997   /* Get the value of the symbol referred to by the reloc.  */
9998   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
9999                            &pic_ext_target);
10000
10001   /* This condition only happened when symbol is undefined.  */
10002   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10003       || foff >= CONSERVATIVE_24BIT_S1)
10004     return FALSE;
10005
10006   /* Relax to: jal symbol; 25_PCREL */
10007   /* For simplicity of coding, we are going to modify the section
10008      contents, the section relocs, and the BFD symbol table.  We
10009      must tell the rest of the code not to free up this
10010      information.  It would be possible to instead create a table
10011      of changes which have to be made, as is done in coff-mips.c;
10012      that would be more work, but would require less memory when
10013      the linker is run.  */
10014
10015   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10016                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
10017   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10018                                           R_NDS32_EMPTY, irel->r_addend);
10019
10020   if (ptr_irel == irelend || em_irel == irelend)
10021     {
10022       (*_bfd_error_handler)
10023         ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
10024          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10025       return FALSE;
10026     }
10027   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10028   insn = bfd_getb32 (contents + irel->r_addend);
10029   if (insn & 0x80000000)
10030     return FALSE;
10031
10032   /* Replace the long call with a jal.  */
10033   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10034                                   R_NDS32_25_PCREL_RELA);
10035   ptr_irel->r_addend = 1;
10036
10037   /* We don't resolve this here but resolve it in relocate_section.  */
10038   insn = INSN_JAL;
10039   bfd_putb32 (insn, contents + em_irel->r_offset);
10040
10041   irel->r_info =
10042     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10043
10044   /* If there is function cse, HI20 can not remove now.  */
10045   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10046                                            R_NDS32_LONGCALL4, laddr);
10047   if (call_irel == irelend)
10048     {
10049       *insn_len = 0;
10050       hi_irel->r_info =
10051         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10052     }
10053
10054   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10055                                           R_NDS32_INSN16, irel->r_addend);
10056   if (insn_irel != irelend)
10057     insn_irel->r_info =
10058       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10059
10060   return TRUE;
10061 }
10062
10063 /* Relax LONGCALL5 relocation for nds32_elf_relax_section.  */
10064
10065 static bfd_boolean
10066 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10067                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10068                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10069                            Elf_Internal_Shdr *symtab_hdr)
10070 {
10071   /* The pattern for LONGCALL5.
10072      bltz  rt, .L1      ; LONGCALL5/17_PCREL
10073      jal   symbol       ; 25_PCREL
10074      .L1:  */
10075
10076   bfd_vma laddr;
10077   uint32_t insn;
10078   Elf_Internal_Rela *cond_irel, *irelend;
10079   int pic_ext_target = 0;
10080   bfd_signed_vma foff;
10081
10082   irelend = internal_relocs + sec->reloc_count;
10083   laddr = irel->r_offset;
10084   insn = bfd_getb32 (contents + laddr);
10085
10086   /* Get the reloc for the address from which the register is
10087      being loaded.  This reloc will tell us which function is
10088      actually being called.  */
10089   cond_irel =
10090     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10091                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
10092   if (cond_irel == irelend)
10093     {
10094       (*_bfd_error_handler)
10095         ("%B: warning: R_NDS32_LONGCALL5 points to unrecognized"
10096          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10097       return FALSE;
10098     }
10099
10100   /* Get the value of the symbol referred to by the reloc.  */
10101   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10102                            &pic_ext_target);
10103
10104   if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10105       || foff >= CONSERVATIVE_16BIT_S1)
10106     return FALSE;
10107
10108   /* Relax to   bgezal   rt, label ; 17_PCREL
10109      or         bltzal   rt, label ; 17_PCREL */
10110
10111   /* Convert to complimentary conditional call.  */
10112   insn = CONVERT_CONDITION_CALL (insn);
10113
10114   /* For simplicity of coding, we are going to modify the section
10115      contents, the section relocs, and the BFD symbol table.  We
10116      must tell the rest of the code not to free up this
10117      information.  It would be possible to instead create a table
10118      of changes which have to be made, as is done in coff-mips.c;
10119      that would be more work, but would require less memory when
10120      the linker is run.  */
10121
10122   /* Modify relocation and contents.  */
10123   cond_irel->r_info =
10124     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10125
10126   /* Replace the long call with a bgezal.  */
10127   bfd_putb32 (insn, contents + cond_irel->r_offset);
10128   *insn_len = 0;
10129
10130   /* Clean unnessary relocations.  */
10131   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10132
10133   cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10134                                            R_NDS32_17_PCREL_RELA, laddr);
10135   cond_irel->r_info =
10136     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10137
10138   return TRUE;
10139 }
10140
10141 /* Relax LONGCALL6 relocation for nds32_elf_relax_section.  */
10142
10143 static bfd_boolean
10144 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10145                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10146                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10147                            Elf_Internal_Shdr *symtab_hdr)
10148 {
10149   /* The pattern for LONGCALL6.
10150      bltz  rt,   .L1                    ; LONGCALL6/17_PCREL
10151      sethi ta,   hi20(symbol)           ; HI20/PTR
10152      ori   ta, ta,  lo12(symbol)        ; LO12S0_ORI/PTR
10153      jral  ta                           ; PTR_RES/EMPTY/INSN16
10154      .L1  */
10155
10156   bfd_vma laddr;
10157   uint32_t insn;
10158   Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10159   int pic_ext_target = 0;
10160   bfd_signed_vma foff;
10161
10162   irelend = internal_relocs + sec->reloc_count;
10163   laddr = irel->r_offset;
10164
10165   /* Get the reloc for the address from which the register is
10166      being loaded.  This reloc will tell us which function is
10167      actually being called.  */
10168   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10169                                          R_NDS32_EMPTY, irel->r_addend);
10170
10171   if (em_irel == irelend)
10172     {
10173       (*_bfd_error_handler)
10174         ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10175          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10176       return FALSE;
10177     }
10178
10179   /* Get the value of the symbol referred to by the reloc.  */
10180   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10181                            &pic_ext_target);
10182
10183   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10184       || foff >= CONSERVATIVE_24BIT_S1)
10185     return FALSE;
10186
10187   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10188   insn = bfd_getb32 (contents + irel->r_addend);
10189   if (insn & 0x80000000)
10190     return FALSE;
10191
10192   insn = bfd_getb32 (contents + laddr);
10193   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10194     {
10195       /* Relax to  bgezal   rt, label ; 17_PCREL
10196          or        bltzal   rt, label ; 17_PCREL */
10197
10198       /* Convert to complimentary conditional call.  */
10199       *insn_len = 0;
10200       insn = CONVERT_CONDITION_CALL (insn);
10201       bfd_putb32 (insn, contents + em_irel->r_offset);
10202
10203       em_irel->r_info =
10204         ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10205
10206       /* Set resolved relocation.  */
10207       cond_irel =
10208         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10209                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10210       if (cond_irel == irelend)
10211         {
10212           (*_bfd_error_handler)
10213             ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10214              "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10215           return FALSE;
10216         }
10217       cond_irel->r_addend = 1;
10218
10219       /* Clear relocations.  */
10220
10221       irel->r_info =
10222         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10223
10224       cond_irel =
10225         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10226                                      R_NDS32_17_PCREL_RELA, laddr);
10227       if (cond_irel != irelend)
10228         cond_irel->r_info =
10229           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10230
10231       cond_irel =
10232         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10233                                      R_NDS32_INSN16, irel->r_addend);
10234       if (cond_irel != irelend)
10235         cond_irel->r_info =
10236           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10237
10238     }
10239   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10240     {
10241       /* Relax to the following instruction sequence
10242          bltz  rt, .L1  ; LONGCALL2/17_PCREL
10243          jal   symbol   ; 25_PCREL/PTR_RES
10244          .L1  */
10245       *insn_len = 4;
10246       /* Convert instruction.  */
10247       insn = INSN_JAL;
10248       bfd_putb32 (insn, contents + em_irel->r_offset);
10249
10250       /* Convert relocations.  */
10251       em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10252                                       R_NDS32_25_PCREL_RELA);
10253       irel->r_info =
10254         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10255
10256       /* Set resolved relocation.  */
10257       cond_irel =
10258         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10259                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10260       if (cond_irel == irelend)
10261         {
10262           (*_bfd_error_handler)
10263             ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10264              "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10265           return FALSE;
10266         }
10267       cond_irel->r_addend = 1;
10268
10269       cond_irel =
10270         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10271                                      R_NDS32_INSN16, irel->r_addend);
10272       if (cond_irel != irelend)
10273         cond_irel->r_info =
10274           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10275     }
10276   return TRUE;
10277 }
10278
10279 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section.  */
10280
10281 static bfd_boolean
10282 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10283                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10284                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10285                            Elf_Internal_Shdr *symtab_hdr)
10286 {
10287   /* The pattern for LONGJUMP4.
10288      sethi ta, hi20(symbol)     ; LONGJUMP4/HI20
10289      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10290      jr    ta                   ; PTR_RES/INSN16/EMPTY  */
10291
10292   bfd_vma laddr;
10293   int seq_len;  /* Original length of instruction sequence.  */
10294   uint32_t insn;
10295   Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10296   int pic_ext_target = 0;
10297   bfd_signed_vma foff;
10298
10299   irelend = internal_relocs + sec->reloc_count;
10300   seq_len = GET_SEQ_LEN (irel->r_addend);
10301   laddr = irel->r_offset;
10302   *insn_len = seq_len;
10303
10304   /* Get the reloc for the address from which the register is
10305      being loaded.  This reloc will tell us which function is
10306      actually being called.  */
10307
10308   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10309                                          R_NDS32_HI20_RELA, laddr);
10310
10311   if (hi_irel == irelend)
10312     {
10313       (*_bfd_error_handler)
10314         ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10315          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10316       return FALSE;
10317     }
10318
10319   /* Get the value of the symbol referred to by the reloc.  */
10320   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10321                            &pic_ext_target);
10322
10323   if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10324       || foff < -CONSERVATIVE_24BIT_S1)
10325     return FALSE;
10326
10327   /* Convert it to "j label", it may be converted to j8 in the final
10328      pass of relaxation.  Therefore, we do not consider this currently.  */
10329   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10330                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
10331   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10332                                          R_NDS32_EMPTY, irel->r_addend);
10333
10334   if (ptr_irel == irelend || em_irel == irelend)
10335     {
10336       (*_bfd_error_handler)
10337         ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10338          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10339       return FALSE;
10340     }
10341
10342   em_irel->r_info =
10343     ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10344   ptr_irel->r_addend = 1;
10345
10346   /* Write instruction.  */
10347   insn = INSN_J;
10348   bfd_putb32 (insn, contents + em_irel->r_offset);
10349
10350   /* Clear relocations.  */
10351   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10352
10353   /* If there is function cse, HI20 can not remove now.  */
10354   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10355                                            R_NDS32_LONGJUMP4, laddr);
10356   if (call_irel == irelend)
10357     {
10358       *insn_len = 0;
10359       hi_irel->r_info =
10360         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10361     }
10362
10363   return TRUE;
10364 }
10365
10366 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section.  */
10367
10368 static bfd_boolean
10369 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10370                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10371                            int *seq_len, bfd_byte *contents,
10372                            Elf_Internal_Sym *isymbuf,
10373                            Elf_Internal_Shdr *symtab_hdr)
10374 {
10375   /* There are 2 variations for LONGJUMP5
10376      case 2-4;  1st insn convertible, 16-bit on.
10377      bnes38  rt, ra, .L1        ; LONGJUMP5/9_PCREL/INSN16
10378      j       label              ; 25_PCREL/INSN16
10379      $1:
10380
10381      case 4-4; 1st insn not convertible
10382      bne  rt, ra, .L1   ; LONGJUMP5/15_PCREL/INSN16
10383      j    label         ; 25_PCREL/INSN16
10384      .L1:  */
10385
10386   bfd_vma laddr;
10387   Elf_Internal_Rela *cond_irel,  *irelend;
10388   int pic_ext_target = 0;
10389   unsigned int i;
10390   bfd_signed_vma foff;
10391   uint32_t insn, re_insn = 0;
10392   uint16_t insn16, re_insn16 = 0;
10393   unsigned long reloc;
10394
10395   enum elf_nds32_reloc_type checked_types[] =
10396     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10397       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10398
10399   irelend = internal_relocs + sec->reloc_count;
10400   laddr = irel->r_offset;
10401
10402   /* Get the reloc for the address from which the register is
10403      being loaded.  This reloc will tell us which function is
10404      actually being called.  */
10405
10406   cond_irel =
10407     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10408                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
10409   if (cond_irel == irelend)
10410     {
10411       (*_bfd_error_handler)
10412         ("%B: warning: R_NDS32_LONGJUMP5 points to unrecognized"
10413          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10414       return FALSE;
10415     }
10416
10417   /* Get the value of the symbol referred to by the reloc.  */
10418   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10419                            &pic_ext_target);
10420
10421   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10422       || foff >= CONSERVATIVE_16BIT_S1)
10423     return FALSE;
10424
10425   /* Get the all corresponding instructions.  */
10426   insn = bfd_getb32 (contents + laddr);
10427   /* Check instruction size.  */
10428   if (insn & 0x80000000)
10429     {
10430       *seq_len = 0;
10431       insn16 = insn >> 16;
10432       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10433     }
10434   else
10435     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10436
10437   if (N32_OP6 (re_insn) == N32_OP6_BR1
10438       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10439     {
10440       /* beqs label ; 15_PCREL.  */
10441       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10442       reloc = R_NDS32_15_PCREL_RELA;
10443     }
10444   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10445            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10446     {
10447       /* beqz label ; 17_PCREL.  */
10448       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10449       reloc = R_NDS32_17_PCREL_RELA;
10450     }
10451   else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10452            && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10453     {
10454       /* beqc label ; 9_PCREL.  */
10455       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10456       reloc = R_NDS32_WORD_9_PCREL_RELA;
10457     }
10458   else
10459     return FALSE;
10460
10461   /* Set all relocations.  */
10462   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10463
10464   /* Clean relocations.  */
10465   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10466   for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10467     {
10468       cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10469                                                checked_types[i], laddr);
10470       if (cond_irel != irelend)
10471         {
10472           if (*seq_len == 0
10473               && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10474             {
10475               /* If the branch instruction is 2 byte, it cannot remove
10476                  directly.  Only convert it to nop16 and remove it after
10477                  checking alignment issue.  */
10478               insn16 = NDS32_NOP16;
10479               bfd_putb16 (insn16, contents + laddr);
10480               cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10481             }
10482           else
10483             cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10484                                               R_NDS32_NONE);
10485         }
10486     }
10487   *insn_len = 0;
10488
10489   return TRUE;
10490 }
10491
10492 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section.  */
10493
10494 static bfd_boolean
10495 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10496                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10497                            int *seq_len, bfd_byte *contents,
10498                            Elf_Internal_Sym *isymbuf,
10499                            Elf_Internal_Shdr *symtab_hdr)
10500 {
10501   /* There are 5 variations for LONGJUMP6
10502      case : 2-4-4-4; 1st insn convertible, 16-bit on.
10503      bnes38   rt, ra, .L1               ; LONGJUMP6/15_PCREL/INSN16
10504      sethi    ta, hi20(symbol)          ; HI20/PTR
10505      ori      ta, ta, lo12(symbol)      ; LO12S0_ORI/PTR
10506      jr       ta                        ; PTR_RES/INSN16/EMPTY
10507      .L1:
10508
10509      case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10510      bne   rt, ra, .L1          ; LONGJUMP6/15_PCREL/INSN16
10511      sethi ta, hi20(symbol)     ; HI20/PTR
10512      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10513      jr    ta                   ; PTR_RES/INSN16/EMPTY
10514      .L1:  */
10515
10516   enum elf_nds32_reloc_type checked_types[] =
10517     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10518       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10519
10520   int reloc_off = 0, cond_removed = 0;
10521   bfd_vma laddr;
10522   Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10523   int pic_ext_target = 0;
10524   unsigned int i;
10525   bfd_signed_vma foff;
10526   uint32_t insn, re_insn = 0;
10527   uint16_t insn16, re_insn16 = 0;
10528   unsigned long reloc;
10529
10530   irelend = internal_relocs + sec->reloc_count;
10531   laddr = irel->r_offset;
10532
10533   /* Get the reloc for the address from which the register is
10534      being loaded.  This reloc will tell us which function is
10535      actually being called.  */
10536   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10537                                          R_NDS32_EMPTY, irel->r_addend);
10538
10539   if (em_irel == irelend)
10540     {
10541       (*_bfd_error_handler)
10542         ("%B: warning: R_NDS32_LONGJUMP6 points to unrecognized"
10543          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10544       return FALSE;
10545     }
10546
10547   /* Get the value of the symbol referred to by the reloc.  */
10548   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10549                            &pic_ext_target);
10550
10551   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10552       || foff >= CONSERVATIVE_24BIT_S1)
10553     return FALSE;
10554
10555   insn = bfd_getb32 (contents + laddr);
10556   /* Check instruction size.  */
10557   if (insn & 0x80000000)
10558     {
10559       *seq_len = 0;
10560       insn16 = insn >> 16;
10561       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10562     }
10563   else
10564     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10565
10566   /* For simplicity of coding, we are going to modify the section
10567      contents, the section relocs, and the BFD symbol table.  We
10568      must tell the rest of the code not to free up this
10569      information.  It would be possible to instead create a table
10570      of changes which have to be made, as is done in coff-mips.c;
10571      that would be more work, but would require less memory when
10572      the linker is run.  */
10573
10574   if (N32_OP6 (re_insn) == N32_OP6_BR1
10575       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10576     {
10577       /* beqs     label    ; 15_PCREL */
10578       bfd_putb32 (re_insn, contents + em_irel->r_offset);
10579       reloc = R_NDS32_15_PCREL_RELA;
10580       cond_removed = 1;
10581     }
10582   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10583            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10584     {
10585       /* beqz     label ; 17_PCREL */
10586       bfd_putb32 (re_insn, contents + em_irel->r_offset);
10587       reloc = R_NDS32_17_PCREL_RELA;
10588       cond_removed = 1;
10589     }
10590   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10591            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10592     {
10593       /* Relax to one of the following 2 variations
10594
10595          case 2-4;  1st insn convertible, 16-bit on.
10596          bnes38  rt, ra, .L1    ; LONGJUMP5/9_PCREL/INSN16
10597          j       label          ; 25_PCREL/INSN16
10598          $1:
10599
10600          case 4-4; 1st insn not convertible
10601          bne  rt, ra, .L1       ; LONGJUMP5/15_PCREL/INSN16
10602          j    label             ; 25_PCREL/INSN16
10603          .L1:  */
10604
10605       /* Use j label as second instruction.  */
10606       insn = INSN_J;
10607       reloc = R_NDS32_25_PCREL_RELA;
10608       bfd_putb32 (insn, contents + em_irel->r_offset);
10609     }
10610   else
10611     return FALSE;
10612
10613   /* Set all relocations.  */
10614   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10615
10616   cond_irel =
10617     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10618                                  R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10619   cond_irel->r_addend = 1;
10620
10621   /* Use INSN16 of first branch instruction to distinguish if keeping
10622      INSN16 of final instruction or not.  */
10623   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10624                                            R_NDS32_INSN16, irel->r_offset);
10625   if (insn_irel == irelend)
10626     {
10627       /* Clean the final INSN16.  */
10628       insn_irel =
10629         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10630                                      R_NDS32_INSN16, em_irel->r_offset);
10631       insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10632                                         R_NDS32_NONE);
10633     }
10634
10635   if (cond_removed == 1)
10636     {
10637       *insn_len = 0;
10638
10639       /* Clear relocations.  */
10640       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10641
10642       for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10643         {
10644           cond_irel =
10645             find_relocs_at_address_addr (irel, internal_relocs, irelend,
10646                                          checked_types[i], laddr);
10647           if (cond_irel != irelend)
10648             {
10649               if (*seq_len == 0
10650                   && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10651                 {
10652                   /* If the branch instruction is 2 byte, it cannot remove
10653                      directly.  Only convert it to nop16 and remove it after
10654                      checking alignment issue.  */
10655                   insn16 = NDS32_NOP16;
10656                   bfd_putb16 (insn16, contents + laddr);
10657                   cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10658                 }
10659               else
10660                 cond_irel->r_info =
10661                   ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10662             }
10663         }
10664     }
10665   else
10666     {
10667       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10668                                    R_NDS32_LONGJUMP5);
10669     }
10670
10671   return TRUE;
10672 }
10673
10674 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section.  */
10675
10676 static bfd_boolean
10677 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10678                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10679                            int *seq_len, bfd_byte *contents,
10680                            Elf_Internal_Sym *isymbuf,
10681                            Elf_Internal_Shdr *symtab_hdr)
10682 {
10683   /* There are 2 variations for LONGJUMP5
10684      case 2-4;  1st insn convertible, 16-bit on.
10685      movi55  ta, imm11          ; LONGJUMP7/INSN16
10686      beq     rt, ta, label      ; 15_PCREL
10687
10688      case 4-4; 1st insn not convertible
10689      movi55  ta, imm11          ; LONGJUMP7/INSN16
10690      beq     rt, ta, label      ; 15_PCREL  */
10691
10692   bfd_vma laddr;
10693   Elf_Internal_Rela *cond_irel,  *irelend, *insn_irel;
10694   int pic_ext_target = 0;
10695   bfd_signed_vma foff;
10696   uint32_t insn, re_insn = 0;
10697   uint16_t insn16;
10698   uint32_t imm11;
10699
10700   irelend = internal_relocs + sec->reloc_count;
10701   laddr = irel->r_offset;
10702
10703   /* Get the reloc for the address from which the register is
10704      being loaded.  This reloc will tell us which function is
10705      actually being called.  */
10706
10707   cond_irel =
10708     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10709                                  R_NDS32_15_PCREL_RELA, irel->r_addend);
10710   if (cond_irel == irelend)
10711     {
10712       (*_bfd_error_handler)
10713         ("%B: warning: R_NDS32_LONGJUMP7 points to unrecognized"
10714          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10715       return FALSE;
10716     }
10717
10718   /* Get the value of the symbol referred to by the reloc.  */
10719   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10720                            &pic_ext_target);
10721
10722   if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10723       || foff >= CONSERVATIVE_8BIT_S1)
10724     return FALSE;
10725
10726   /* Get the first instruction for its size.  */
10727   insn = bfd_getb32 (contents + laddr);
10728   if (insn & 0x80000000)
10729     {
10730       *seq_len = 0;
10731       /* Get the immediate from movi55.  */
10732       imm11 = N16_IMM5S (insn >> 16);
10733     }
10734   else
10735     {
10736       /* Get the immediate from movi.  */
10737       imm11 = N32_IMM20S (insn);
10738     }
10739
10740   /* Get the branch instruction.  */
10741   insn = bfd_getb32 (contents + irel->r_addend);
10742   /* Convert instruction to BR3.  */
10743   if ((insn >> 14) & 0x1)
10744     re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10745   else
10746     re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10747
10748   bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10749
10750   /* Set all relocations.  */
10751   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10752                                     R_NDS32_WORD_9_PCREL_RELA);
10753
10754   /* Clean relocations.  */
10755   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10756   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10757                                            R_NDS32_INSN16, irel->r_offset);
10758   if (insn_irel != irelend)
10759     {
10760       if (*seq_len == 0)
10761         {
10762           /* If the first insntruction is 16bit, convert it to nop16.  */
10763           insn16 = NDS32_NOP16;
10764           bfd_putb16 (insn16, contents + laddr);
10765           insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10766         }
10767       else
10768         cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10769                                           R_NDS32_NONE);
10770     }
10771   *insn_len = 0;
10772
10773   return TRUE;
10774 }
10775
10776 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10777
10778 /* Relax LOADSTORE relocation for nds32_elf_relax_section.  */
10779
10780 static bfd_boolean
10781 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10782                            asection *sec, Elf_Internal_Rela *irel,
10783                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10784                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10785                            Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10786 {
10787   int eliminate_sethi = 0, range_type, i;
10788   bfd_vma local_sda, laddr;
10789   int seq_len;  /* Original length of instruction sequence.  */
10790   uint32_t insn;
10791   Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10792   bfd_vma access_addr = 0;
10793   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
10794   enum elf_nds32_reloc_type checked_types[] =
10795     { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10796       R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10797       R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10798       R_NDS32_TLS_LE_HI20
10799     };
10800
10801   irelend = internal_relocs + sec->reloc_count;
10802   seq_len = GET_SEQ_LEN (irel->r_addend);
10803   laddr = irel->r_offset;
10804   *insn_len = seq_len;
10805
10806   /* Get the high part relocation.  */
10807   for (i = 0; (unsigned) i < sizeof (checked_types); i++)
10808     {
10809       hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10810                                                checked_types[i], laddr);
10811       if (hi_irelfn != irelend)
10812         break;
10813     }
10814
10815   if (hi_irelfn == irelend)
10816     {
10817       (*_bfd_error_handler)
10818         ("%B: warning: R_NDS32_LOADSTORE points to unrecognized"
10819          "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10820         return FALSE;
10821     }
10822
10823   range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10824   nds32_elf_final_sda_base (sec->output_section->owner,
10825                             link_info, &local_sda, FALSE);
10826
10827   switch (ELF32_R_TYPE (hi_irelfn->r_info))
10828     {
10829     case R_NDS32_HI20_RELA:
10830       insn = bfd_getb32 (contents + laddr);
10831       access_addr =
10832         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10833
10834       if (range_type == NDS32_LOADSTORE_IMM)
10835         {
10836           struct elf_link_hash_entry *h = NULL;
10837           int indx;
10838
10839           if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10840             {
10841               indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10842               h = elf_sym_hashes (abfd)[indx];
10843             }
10844
10845           if ((access_addr < CONSERVATIVE_20BIT)
10846               && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10847             {
10848               eliminate_sethi = 1;
10849               break;
10850             }
10851
10852           /* This is avoid to relax symbol address which is fixed
10853              relocations.  Ex: _stack.  */
10854           if (h && bfd_is_abs_section (h->root.u.def.section))
10855             return FALSE;
10856         }
10857
10858       if (!load_store_relax)
10859         return FALSE;
10860
10861       /* Case for set gp register.  */
10862       if (N32_RT5 (insn) == REG_GP)
10863         break;
10864
10865       if (range_type == NDS32_LOADSTORE_FLOAT_S
10866           || range_type == NDS32_LOADSTORE_FLOAT_S)
10867         {
10868           range_l = sdata_range[0][0];
10869           range_h = sdata_range[0][1];
10870         }
10871       else
10872         {
10873           range_l = sdata_range[1][0];
10874           range_h = sdata_range[1][1];
10875         }
10876       break;
10877
10878     case R_NDS32_GOT_HI20:
10879       access_addr =
10880         calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10881
10882       /* If this symbol is not in .got, the return value will be -1.
10883          Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10884          a negative offset is allowed.  */
10885       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10886           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10887         eliminate_sethi = 1;
10888       break;
10889
10890     case R_NDS32_PLT_GOTREL_HI20:
10891       access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10892                                                   hi_irelfn, symtab_hdr);
10893
10894       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10895           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10896         eliminate_sethi = 1;
10897       break;
10898
10899     case R_NDS32_GOTOFF_HI20:
10900       access_addr =
10901         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10902
10903       if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10904           && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10905         eliminate_sethi = 1;
10906       break;
10907
10908     case R_NDS32_GOTPC_HI20:
10909       /* The access_addr must consider r_addend of hi_irel.  */
10910       access_addr = sec->output_section->vma + sec->output_offset
10911         + irel->r_offset + hi_irelfn->r_addend;
10912
10913       if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10914           && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10915         eliminate_sethi = 1;
10916       break;
10917
10918     case R_NDS32_TLS_LE_HI20:
10919       access_addr =
10920         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10921       BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10922       access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10923       if ((range_type == NDS32_LOADSTORE_IMM)
10924           && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10925           && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10926         eliminate_sethi = 1;
10927       break;
10928
10929     default:
10930       return FALSE;
10931     }
10932
10933   /* Delete sethi instruction.  */
10934   if (eliminate_sethi == 1
10935       || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10936       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10937     {
10938       hi_irelfn->r_info =
10939         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10940       irel->r_info =
10941         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10942       *insn_len = 0;
10943     }
10944   return TRUE;
10945 }
10946
10947 /* Relax LO12 relocation for nds32_elf_relax_section.  */
10948
10949 static void
10950 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10951                       asection *sec, Elf_Internal_Rela *irel,
10952                       Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10953                       Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10954 {
10955   uint32_t insn;
10956   bfd_vma local_sda, laddr;
10957   unsigned long reloc;
10958   bfd_vma access_addr;
10959   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
10960   Elf_Internal_Rela *irelfn = NULL, *irelend;
10961   struct elf_link_hash_entry *h = NULL;
10962   int indx;
10963
10964   /* For SDA base relative relaxation.  */
10965   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10966                             &local_sda, FALSE);
10967
10968   irelend = internal_relocs + sec->reloc_count;
10969   laddr = irel->r_offset;
10970   insn = bfd_getb32 (contents + laddr);
10971
10972   if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10973     return;
10974
10975   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10976
10977   if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10978     {
10979       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10980       h = elf_sym_hashes (abfd)[indx];
10981     }
10982
10983   if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10984       && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10985     {
10986       reloc = R_NDS32_20_RELA;
10987       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10988       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10989       bfd_putb32 (insn, contents + laddr);
10990     }
10991   /* This is avoid to relax symbol address which is fixed
10992      relocations.  Ex: _stack.  */
10993   else if (N32_OP6 (insn) == N32_OP6_ORI
10994            && h && bfd_is_abs_section (h->root.u.def.section))
10995     return;
10996   else
10997     {
10998       range_l = sdata_range[1][0];
10999       range_h = sdata_range[1][1];
11000       switch (ELF32_R_TYPE (irel->r_info))
11001         {
11002         case R_NDS32_LO12S0_RELA:
11003           reloc = R_NDS32_SDA19S0_RELA;
11004           break;
11005         case R_NDS32_LO12S1_RELA:
11006           reloc = R_NDS32_SDA18S1_RELA;
11007           break;
11008         case R_NDS32_LO12S2_RELA:
11009           reloc = R_NDS32_SDA17S2_RELA;
11010           break;
11011         case R_NDS32_LO12S2_DP_RELA:
11012           range_l = sdata_range[0][0];
11013           range_h = sdata_range[0][1];
11014           reloc = R_NDS32_SDA12S2_DP_RELA;
11015           break;
11016         case R_NDS32_LO12S2_SP_RELA:
11017           range_l = sdata_range[0][0];
11018           range_h = sdata_range[0][1];
11019           reloc = R_NDS32_SDA12S2_SP_RELA;
11020           break;
11021         default:
11022           return;
11023         }
11024
11025       /* There are range_h and range_l because linker has to promise
11026          all sections move cross one page together.  */
11027       if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11028           || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11029         {
11030           if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11031             {
11032               /* Maybe we should add R_NDS32_INSN16 reloc type here
11033                  or manually do some optimization.  sethi can't be
11034                  eliminated when updating $gp so the relative ori
11035                  needs to be preserved.  */
11036               return;
11037             }
11038           if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11039                                         &insn))
11040             return;
11041           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11042           bfd_putb32 (insn, contents + laddr);
11043
11044           irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11045                                            R_NDS32_INSN16);
11046           /* SDA17 must keep INSN16 for converting fp_as_gp.  */
11047           if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11048             irelfn->r_info =
11049               ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11050
11051         }
11052     }
11053   return;
11054 }
11055
11056 /* Relax low part of PIC instruction pattern.  */
11057
11058 static void
11059 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
11060                          asection *sec, Elf_Internal_Rela *irel,
11061                          bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11062                          Elf_Internal_Shdr *symtab_hdr)
11063 {
11064   uint32_t insn;
11065   bfd_vma local_sda, laddr;
11066   bfd_signed_vma foff;
11067   unsigned long reloc;
11068
11069   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11070                             &local_sda, FALSE);
11071   laddr = irel->r_offset;
11072   insn = bfd_getb32 (contents + laddr);
11073
11074   if (N32_OP6 (insn) != N32_OP6_ORI)
11075     return;
11076
11077   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
11078     {
11079       foff = calculate_got_memory_address (abfd, link_info, irel,
11080                                            symtab_hdr) - local_sda;
11081       reloc = R_NDS32_GOT20;
11082     }
11083   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
11084     {
11085       foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
11086                                            symtab_hdr) - local_sda;
11087       reloc = R_NDS32_PLT_GOTREL_LO20;
11088     }
11089   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
11090     {
11091       foff = calculate_memory_address (abfd, irel, isymbuf,
11092                                        symtab_hdr) - local_sda;
11093       reloc = R_NDS32_GOTOFF;
11094     }
11095   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
11096     {
11097       foff = local_sda - sec->output_section->vma + sec->output_offset
11098         + irel->r_offset + irel->r_addend;
11099       reloc = R_NDS32_GOTPC20;
11100     }
11101   else
11102     return;
11103
11104   if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
11105     {
11106       /* Turn into MOVI.  */
11107       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11108       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11109       bfd_putb32 (insn, contents + laddr);
11110     }
11111 }
11112
11113 /* Relax low part of LE TLS instruction pattern.  */
11114
11115 static void
11116 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
11117                            Elf_Internal_Rela *irel,
11118                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11119                            Elf_Internal_Shdr *symtab_hdr)
11120 {
11121   uint32_t insn;
11122   bfd_vma laddr;
11123   bfd_signed_vma foff;
11124   unsigned long reloc;
11125
11126   laddr = irel->r_offset;
11127   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11128   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11129   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11130   insn = bfd_getb32 (contents + laddr);
11131
11132   if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
11133       && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
11134     {
11135       /* Pattern sethi-ori transform to movi.  */
11136       reloc = R_NDS32_TLS_LE_20;
11137       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11138       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11139       bfd_putb32 (insn, contents + laddr);
11140     }
11141 }
11142
11143 /* Relax LE TLS calculate address instruction pattern.  */
11144
11145 static void
11146 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
11147                           asection *sec, Elf_Internal_Rela *irel,
11148                           Elf_Internal_Rela *internal_relocs,
11149                           bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11150                           Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11151 {
11152   /* Local TLS non-pic
11153      sethi    ta, hi20(symbol@tpoff)      ; TLS_LE_HI20
11154      ori      ta, ta, lo12(symbol@tpoff)  ; TLS_LE_LO12
11155      add      ra, ta, tp                  ; TLS_LE_ADD */
11156
11157   uint32_t insn;
11158   bfd_vma laddr;
11159   bfd_signed_vma foff;
11160   Elf_Internal_Rela *i1_irelfn, *irelend;
11161
11162   irelend = internal_relocs + sec->reloc_count;
11163   laddr = irel->r_offset;
11164   insn = bfd_getb32 (contents + laddr);
11165   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11166                                       R_NDS32_PTR_RESOLVED);
11167   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11168   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11169   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11170
11171   /* The range is +/-16k.  */
11172   if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11173       && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11174     {
11175       /* Transform add to addi.  */
11176       insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
11177       irel->r_info =
11178         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11179
11180       bfd_putb32 (insn, contents + laddr);
11181       if (i1_irelfn != irelend)
11182         {
11183           i1_irelfn->r_addend |= 1;
11184           *again = TRUE;
11185         }
11186     }
11187 }
11188
11189 /* Relax LE TLS load store instruction pattern.  */
11190
11191 static void
11192 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
11193                          asection *sec, Elf_Internal_Rela *irel,
11194                          Elf_Internal_Rela *internal_relocs,
11195                          bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11196                          Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11197 {
11198
11199   uint32_t insn;
11200   bfd_vma laddr;
11201   bfd_signed_vma foff;
11202   Elf_Internal_Rela *i1_irelfn, *irelend;
11203   int success = 0;
11204
11205   irelend = internal_relocs + sec->reloc_count;
11206   laddr = irel->r_offset;
11207   insn = bfd_getb32 (contents + laddr);
11208   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11209                                       R_NDS32_PTR_RESOLVED);
11210   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11211   BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11212   foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11213
11214   switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
11215     {
11216     case (N32_OP6_MEM << 8) | N32_MEM_LB:
11217     case (N32_OP6_MEM << 8) | N32_MEM_SB:
11218     case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11219       /* The range is +/-16k.  */
11220       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11221           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11222         {
11223           insn =
11224             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11225           irel->r_info =
11226             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11227           success = 1;
11228           break;
11229         }
11230     case (N32_OP6_MEM << 8) | N32_MEM_LH:
11231     case (N32_OP6_MEM << 8) | N32_MEM_SH:
11232     case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11233       /* The range is +/-32k.  */
11234       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
11235           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
11236         {
11237           insn =
11238             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11239           irel->r_info =
11240             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
11241           success = 1;
11242           break;
11243         }
11244     case (N32_OP6_MEM << 8) | N32_MEM_LW:
11245     case (N32_OP6_MEM << 8) | N32_MEM_SW:
11246       /* The range is +/-64k.  */
11247       if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
11248           && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
11249         {
11250           insn =
11251             ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11252           irel->r_info =
11253             ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
11254           success = 1;
11255           break;
11256         }
11257     default:
11258       break;
11259     }
11260
11261   if (success)
11262     {
11263       bfd_putb32 (insn, contents + laddr);
11264       if (i1_irelfn != irelend)
11265         {
11266           i1_irelfn->r_addend |= 1;
11267           *again = TRUE;
11268         }
11269     }
11270 }
11271
11272 /* Relax PTR relocation for nds32_elf_relax_section.  */
11273
11274 static bfd_boolean
11275 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11276                      Elf_Internal_Rela *internal_relocs, int *insn_len,
11277                      int *seq_len, bfd_byte *contents)
11278 {
11279   Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11280
11281   irelend = internal_relocs + sec->reloc_count;
11282
11283   re_irel =
11284     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11285                                  R_NDS32_PTR_RESOLVED, irel->r_addend);
11286
11287   if (re_irel == irelend)
11288     {
11289       (*_bfd_error_handler)
11290         ("%B: warning: R_NDS32_PTR points to unrecognized reloc at 0x%lx.",
11291          abfd, (long) irel->r_offset);
11292       return FALSE;
11293     }
11294
11295   if (re_irel->r_addend != 1)
11296     return FALSE;
11297
11298   /* Pointed target is relaxed and no longer needs this void *,
11299      change the type to NONE.  */
11300   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11301
11302   /* Find PTR_COUNT to decide remove it or not.  If PTR_COUNT does
11303      not exist, it means only count 1 and remove it directly.  */
11304   /* TODO: I hope we can obsolate R_NDS32_COUNT in the future.  */
11305   count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11306                                        R_NDS32_PTR_COUNT);
11307   ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11308                                      R_NDS32_PTR);
11309   if (count_irel != irelend)
11310     {
11311       if (--count_irel->r_addend > 0)
11312         return FALSE;
11313     }
11314
11315   if (ptr_irel != irelend)
11316     return FALSE;
11317
11318   /* If the PTR_COUNT is already 0, remove current instruction.  */
11319   *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11320   *insn_len = 0;
11321   return TRUE;
11322 }
11323
11324 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section.  */
11325
11326 static void
11327 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11328                              asection *sec, Elf_Internal_Rela *irel,
11329                              Elf_Internal_Rela *internal_relocs,
11330                              bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11331                              Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11332 {
11333   uint32_t insn;
11334   bfd_signed_vma foff;
11335   Elf_Internal_Rela *i1_irelfn, *irelend;
11336   bfd_vma local_sda, laddr;
11337
11338   irelend = internal_relocs + sec->reloc_count;
11339   laddr = irel->r_offset;
11340   insn = bfd_getb32 (contents + laddr);
11341
11342   /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11343      we need additional space.  It might be help if we could
11344      borrow some space from instructions to be eliminated
11345      such as sethi, ori, add.  */
11346   if (insn & 0x80000000)
11347     return;
11348
11349   if (nds32_elf_check_dup_relocs
11350       (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11351     return;
11352
11353   i1_irelfn =
11354     find_relocs_at_address (irel, internal_relocs, irelend,
11355                             R_NDS32_PTR_RESOLVED);
11356
11357   /* FIXIT 090606
11358      The boundary should be reduced since the .plt section hasn't
11359      been created and the address of specific entry is still unknown
11360      Maybe the range between the function call and the begin of the
11361      .text section can be used to decide if the .plt is in the range
11362      of function call.  */
11363
11364   if (N32_OP6 (insn) == N32_OP6_ALU1
11365       && N32_SUB5 (insn) == N32_ALU1_ADD)
11366     {
11367       /* Get the value of the symbol referred to by the reloc.  */
11368       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11369                                 &local_sda, FALSE);
11370       foff = (bfd_signed_vma) (calculate_plt_memory_address
11371                                (abfd, link_info, isymbuf, irel,
11372                                 symtab_hdr) - local_sda);
11373       /* This condition only happened when symbol is undefined.  */
11374       if (foff == 0)
11375         return;
11376
11377       if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11378         return;
11379       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11380                                    R_NDS32_PLT_GOTREL_LO19);
11381       /* addi.gp */
11382       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11383     }
11384   else if (N32_OP6 (insn) == N32_OP6_JREG
11385            && N32_SUB5 (insn) == N32_JREG_JRAL)
11386     {
11387       /* Get the value of the symbol referred to by the reloc.  */
11388       foff =
11389         calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11390       /* This condition only happened when symbol is undefined.  */
11391       if (foff == 0)
11392         return;
11393       if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11394         return;
11395       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11396       insn = INSN_JAL;
11397     }
11398   else
11399     return;
11400
11401   bfd_putb32 (insn, contents + laddr);
11402   if (i1_irelfn != irelend)
11403     {
11404       i1_irelfn->r_addend |= 1;
11405       *again = TRUE;
11406     }
11407 }
11408
11409 /* Relax GOT_SUFF relocation for nds32_elf_relax_section.  */
11410
11411 static void
11412 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11413                           asection *sec, Elf_Internal_Rela *irel,
11414                           Elf_Internal_Rela *internal_relocs,
11415                           bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11416                           bfd_boolean *again)
11417 {
11418   uint32_t insn;
11419   bfd_signed_vma foff;
11420   Elf_Internal_Rela *i1_irelfn, *irelend;
11421   bfd_vma local_sda, laddr;
11422
11423   irelend = internal_relocs + sec->reloc_count;
11424   laddr = irel->r_offset;
11425   insn = bfd_getb32 (contents + laddr);
11426   if (insn & 0x80000000)
11427     return;
11428
11429   if (nds32_elf_check_dup_relocs
11430       (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11431     return;
11432
11433   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11434                                       R_NDS32_PTR_RESOLVED);
11435
11436   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11437                             &local_sda, FALSE);
11438   foff = calculate_got_memory_address (abfd, link_info, irel,
11439                                        symtab_hdr) - local_sda;
11440
11441   if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11442     {
11443       /* Turn LW to LWI.GP.  Change relocation type to R_NDS32_GOT_REL.  */
11444       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11445       irel->r_info =
11446         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11447       bfd_putb32 (insn, contents + laddr);
11448       if (i1_irelfn != irelend)
11449         {
11450           i1_irelfn->r_addend |= 1;
11451           *again = TRUE;
11452         }
11453     }
11454 }
11455
11456 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section.  */
11457
11458 static void
11459 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11460                              asection *sec, Elf_Internal_Rela *irel,
11461                              Elf_Internal_Rela *internal_relocs,
11462                              bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11463                              Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11464 {
11465   int opc_insn_gotoff;
11466   uint32_t insn;
11467   bfd_signed_vma foff;
11468   Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11469   bfd_vma local_sda, laddr;
11470
11471   irelend = internal_relocs + sec->reloc_count;
11472   laddr = irel->r_offset;
11473   insn = bfd_getb32 (contents + laddr);
11474
11475   if (insn & 0x80000000)
11476     return;
11477
11478   if (nds32_elf_check_dup_relocs
11479       (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11480     return;
11481
11482   i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11483                                       R_NDS32_PTR_RESOLVED);
11484   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11485                             &local_sda, FALSE);
11486   foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11487   foff = foff - local_sda;
11488
11489   if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11490     return;
11491
11492   /* Concatenate opcode and sub-opcode for switch case.
11493      It may be MEM or ALU1.  */
11494   opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11495   switch (opc_insn_gotoff)
11496     {
11497     case (N32_OP6_MEM << 8) | N32_MEM_LW:
11498       /* 4-byte aligned.  */
11499       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11500       irel->r_info =
11501         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11502       break;
11503     case (N32_OP6_MEM << 8) | N32_MEM_SW:
11504       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11505       irel->r_info =
11506         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11507       break;
11508     case (N32_OP6_MEM << 8) | N32_MEM_LH:
11509       /* 2-byte aligned.  */
11510       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11511       irel->r_info =
11512         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11513       break;
11514     case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11515       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
11516       irel->r_info =
11517         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11518       break;
11519     case (N32_OP6_MEM << 8) | N32_MEM_SH:
11520       insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
11521       irel->r_info =
11522         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11523       break;
11524     case (N32_OP6_MEM << 8) | N32_MEM_LB:
11525       /* 1-byte aligned.  */
11526       insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11527       irel->r_info =
11528         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11529       break;
11530     case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11531       insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
11532       irel->r_info =
11533         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11534       break;
11535     case (N32_OP6_MEM << 8) | N32_MEM_SB:
11536       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11537       irel->r_info =
11538         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11539       break;
11540     case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11541       insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11542       irel->r_info =
11543         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11544       break;
11545     default:
11546       return;
11547     }
11548
11549   bfd_putb32 (insn, contents + laddr);
11550   if (i1_irelfn != irelend)
11551     {
11552       i1_irelfn->r_addend |= 1;
11553       *again = TRUE;
11554     }
11555   if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11556                                            R_NDS32_INSN16)) != irelend)
11557     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11558
11559 }
11560
11561 static bfd_boolean
11562 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11563                           Elf_Internal_Rela *internal_relocs,
11564                           bfd_byte *contents,
11565                           nds32_elf_blank_t **relax_blank_list,
11566                           int optimize, int opt_size)
11567 {
11568   /* This code block is used to adjust 4-byte alignment by relax a pair
11569      of instruction a time.
11570
11571      It recognizes three types of relocations.
11572      1. R_NDS32_LABEL - a aligment.
11573      2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11574      3. is_16bit_NOP () - remove a 16-bit instruction.  */
11575
11576   /* TODO: It seems currently implementation only support 4-byte aligment.
11577      We should handle any-aligment.  */
11578
11579   Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11580   Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11581   Elf_Internal_Rela rel_temp;
11582   Elf_Internal_Rela *irelend;
11583   bfd_vma address;
11584   uint16_t insn16;
11585
11586   /* Checking for branch relaxation relies on the relocations to
11587      be sorted on 'r_offset'.  This is not guaranteed so we must sort.  */
11588   nds32_insertion_sort (internal_relocs, sec->reloc_count,
11589                         sizeof (Elf_Internal_Rela), compar_reloc);
11590
11591   irelend = internal_relocs + sec->reloc_count;
11592
11593   /* Force R_NDS32_LABEL before R_NDS32_INSN16.  */
11594   /* FIXME: Can we generate the right order in assembler?
11595      So we don't have to swapping them here.  */
11596
11597   for (label_rel = internal_relocs, insn_rel = internal_relocs;
11598        label_rel < irelend; label_rel++)
11599     {
11600       if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11601         continue;
11602
11603       /* Find the first reloc has the same offset with label_rel.  */
11604       while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11605         insn_rel++;
11606
11607       for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11608            insn_rel++)
11609         /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11610            address.  */
11611         if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11612           break;
11613
11614       if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11615           && insn_rel < label_rel)
11616         {
11617           /* Swap the two reloc if the R_NDS32_INSN16 is
11618              before R_NDS32_LABEL.  */
11619           memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11620           memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11621           memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11622         }
11623     }
11624
11625   label_rel = NULL;
11626   insn_rel = NULL;
11627   /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11628      or higher, remove other R_NDS32_LABEL with lower alignment.
11629      If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11630      then the R_NDS32_LABEL sequence is broke.  */
11631   for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11632     {
11633       if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11634         {
11635           if (label_rel == NULL)
11636             {
11637               if (tmp_rel->r_addend < 2)
11638                 label_rel = tmp_rel;
11639               continue;
11640             }
11641           else if (tmp_rel->r_addend > 1)
11642             {
11643               /* Remove all LABEL relocation from label_rel to tmp_rel
11644                  including relocations with same offset as tmp_rel.  */
11645               for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11646                    || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11647                 {
11648                   if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11649                       && tmp2_rel->r_addend < 2)
11650                     tmp2_rel->r_info =
11651                       ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11652                                     R_NDS32_NONE);
11653                 }
11654               label_rel = NULL;
11655             }
11656         }
11657       else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11658         {
11659           /* A new INSN16 which can be converted, so clear label_rel.  */
11660           if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11661                                    irelend, &insn16)
11662               || is_16bit_NOP (abfd, sec, tmp_rel))
11663             label_rel = NULL;
11664         }
11665     }
11666
11667   label_rel = NULL;
11668   insn_rel = NULL;
11669   /* Optimized for speed and nothing has not been relaxed.
11670      It's time to align labels.
11671      We may convert a 16-bit instruction right before a label to
11672      32-bit, in order to align the label if necessary
11673      all reloc entries has been sorted by r_offset.  */
11674   for (irel = internal_relocs; irel < irelend; irel++)
11675     {
11676       if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11677           && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11678         continue;
11679
11680       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11681         {
11682           /* A new INSN16 found, resize the old one.  */
11683           if (is_convert_32_to_16
11684               (abfd, sec, irel, internal_relocs, irelend, &insn16)
11685               || is_16bit_NOP (abfd, sec, irel))
11686             {
11687               if (insn_rel)
11688                 {
11689                   /* Previous INSN16 reloc exists, reduce its
11690                      size to 16-bit.  */
11691                   if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11692                                            irelend, &insn16))
11693                     {
11694                       nds32_elf_write_16 (abfd, contents, insn_rel,
11695                                           internal_relocs, irelend, insn16);
11696
11697                       if (!insert_nds32_elf_blank_recalc_total
11698                           (relax_blank_list, insn_rel->r_offset + 2, 2))
11699                         return FALSE;
11700                     }
11701                   else if (is_16bit_NOP (abfd, sec, insn_rel))
11702                     {
11703                       if (!insert_nds32_elf_blank_recalc_total
11704                           (relax_blank_list, insn_rel->r_offset, 2))
11705                         return FALSE;
11706                     }
11707                   insn_rel->r_info =
11708                     ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11709                 }
11710               /* Save the new one for later use.  */
11711               insn_rel = irel;
11712             }
11713           else
11714             irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11715                                          R_NDS32_NONE);
11716         }
11717       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11718         {
11719           /* Search for label.  */
11720           int force_relax = 0;
11721
11722           /* Label on 16-bit instruction or optimization
11723              needless, just reset this reloc.  */
11724           insn16 = bfd_getb16 (contents + irel->r_offset);
11725           if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11726             {
11727               irel->r_info =
11728                 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11729               continue;
11730             }
11731
11732           address =
11733             irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11734                                                         irel->r_offset, 1);
11735
11736           if (!insn_rel)
11737             {
11738               /* Check if there is case which can not be aligned.  */
11739               if (irel->r_addend == 2 && address & 0x2)
11740                 return FALSE;
11741               continue;
11742             }
11743
11744           /* Try to align this label.  */
11745
11746           if ((irel->r_addend & 0x1f) < 2)
11747             {
11748               /* Check if there is a INSN16 at the same address.
11749                  Label_rel always seats before insn_rel after
11750                  our sort.  */
11751
11752               /* Search for INSN16 at LABEL location.  If INSN16 is at
11753                  same location and this LABEL alignment is lower than 2,
11754                  the INSN16 can be converted to 2-byte.  */
11755               for (tmp_rel = irel;
11756                    tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11757                    tmp_rel++)
11758                 {
11759                   if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11760                       && (is_convert_32_to_16
11761                           (abfd, sec, tmp_rel, internal_relocs,
11762                            irelend, &insn16)
11763                           || is_16bit_NOP (abfd, sec, tmp_rel)))
11764                     {
11765                       force_relax = 1;
11766                       break;
11767                     }
11768                 }
11769             }
11770
11771           if (force_relax || irel->r_addend == 1 || address & 0x2)
11772             {
11773               /* Label not aligned.  */
11774               /* Previous reloc exists, reduce its size to 16-bit.  */
11775               if (is_convert_32_to_16 (abfd, sec, insn_rel,
11776                                        internal_relocs, irelend, &insn16))
11777                 {
11778                   nds32_elf_write_16 (abfd, contents, insn_rel,
11779                                       internal_relocs, irelend, insn16);
11780
11781                   if (!insert_nds32_elf_blank_recalc_total
11782                       (relax_blank_list, insn_rel->r_offset + 2, 2))
11783                     return FALSE;
11784                 }
11785               else if (is_16bit_NOP (abfd, sec, insn_rel))
11786                 {
11787                   if (!insert_nds32_elf_blank_recalc_total
11788                       (relax_blank_list, insn_rel->r_offset, 2))
11789                     return FALSE;
11790                 }
11791
11792             }
11793           /* INSN16 reloc is used.  */
11794           insn_rel = NULL;
11795         }
11796     }
11797
11798   address =
11799     sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11800   if (insn_rel && (address & 0x2 || opt_size))
11801     {
11802       if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11803                                irelend, &insn16))
11804         {
11805           nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11806                               irelend, insn16);
11807           if (!insert_nds32_elf_blank_recalc_total
11808               (relax_blank_list, insn_rel->r_offset + 2, 2))
11809             return FALSE;
11810           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11811                                            R_NDS32_NONE);
11812         }
11813       else if (is_16bit_NOP (abfd, sec, insn_rel))
11814         {
11815           if (!insert_nds32_elf_blank_recalc_total
11816               (relax_blank_list, insn_rel->r_offset, 2))
11817             return FALSE;
11818           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11819                                            R_NDS32_NONE);
11820         }
11821     }
11822   insn_rel = NULL;
11823   return TRUE;
11824 }
11825
11826 /* Pick relaxation round.  */
11827
11828 static int
11829 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11830                       struct elf_nds32_link_hash_table *table,
11831                       struct bfd_link_info *link_info)
11832 {
11833   static asection *final_sec, *first_sec = NULL;
11834   static bfd_boolean normal_again = FALSE;
11835   static bfd_boolean set = FALSE;
11836   static bfd_boolean first = TRUE;
11837   int round_table[] = {
11838       NDS32_RELAX_NORMAL_ROUND,
11839       NDS32_RELAX_JUMP_IFC_ROUND,
11840       NDS32_RELAX_EX9_BUILD_ROUND,
11841       NDS32_RELAX_EX9_REPLACE_ROUND,
11842   };
11843   static int pass = 0;
11844   static int relax_round;
11845
11846   /* The new round.  */
11847   if (init && first_sec == sec)
11848     {
11849       set = TRUE;
11850       normal_again = FALSE;
11851     }
11852
11853   if (first)
11854     {
11855       /* Run an empty run to get the final section.  */
11856       relax_round = NDS32_RELAX_EMPTY_ROUND;
11857
11858       /* It has to enter relax again because we can
11859          not make sure what the final turn is.  */
11860       *again = TRUE;
11861
11862       first = FALSE;
11863       first_sec = sec;
11864     }
11865
11866   if (!set)
11867     {
11868       /* Not reenter yet.  */
11869       final_sec = sec;
11870       return relax_round;
11871     }
11872
11873   relax_round = round_table[pass];
11874
11875   if (!init && relax_round == NDS32_RELAX_NORMAL_ROUND && *again)
11876     normal_again = TRUE;
11877
11878   if (!init && final_sec == sec)
11879     {
11880       switch (relax_round)
11881         {
11882         case NDS32_RELAX_NORMAL_ROUND:
11883           if (!normal_again)
11884             {
11885               /* Normal relaxation done.  */
11886               if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11887                 {
11888                   pass++;
11889                   *again = TRUE;
11890                 }
11891               else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11892                 {
11893                   pass += 2;    /* NDS32_RELAX_EX9_BUILD_ROUND */
11894                   *again = TRUE;
11895                 }
11896               else if (table->ex9_import_file)
11897                 {
11898                   /* Import ex9 table.  */
11899                   if (table->update_ex9_table)
11900                     pass += 2;  /* NDS32_RELAX_EX9_BUILD_ROUND */
11901                   else
11902                     pass += 3;  /* NDS32_RELAX_EX9_REPLACE_ROUND */
11903                   nds32_elf_ex9_import_table (link_info);
11904                   *again = TRUE;
11905                 }
11906             }
11907           break;
11908         case NDS32_RELAX_JUMP_IFC_ROUND:
11909           if (!nds32_elf_ifc_finish (link_info))
11910             (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11911           if (table->target_optimize & NDS32_RELAX_EX9_ON)
11912             {
11913               pass++;
11914               *again = TRUE;
11915             }
11916           break;
11917         case NDS32_RELAX_EX9_BUILD_ROUND:
11918           nds32_elf_ex9_finish (link_info);
11919           pass++;
11920           *again = TRUE;
11921           break;
11922         case NDS32_RELAX_EX9_REPLACE_ROUND:
11923           if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11924             {
11925               /* Do jump IFC optimization again.  */
11926               if (!nds32_elf_ifc_finish (link_info))
11927                 (*_bfd_error_handler) (_("error: Jump IFC Fail."));
11928             }
11929           break;
11930         default:
11931           break;
11932         }
11933     }
11934
11935   return relax_round;
11936 }
11937
11938 static bfd_boolean
11939 nds32_elf_relax_section (bfd *abfd, asection *sec,
11940                          struct bfd_link_info *link_info, bfd_boolean *again)
11941 {
11942   nds32_elf_blank_t *relax_blank_list = NULL;
11943   Elf_Internal_Shdr *symtab_hdr;
11944   Elf_Internal_Rela *internal_relocs;
11945   Elf_Internal_Rela *irel;
11946   Elf_Internal_Rela *irelend;
11947   Elf_Internal_Sym *isymbuf = NULL;
11948   bfd_byte *contents = NULL;
11949   bfd_boolean result = TRUE;
11950   int optimize = 0;
11951   int opt_size = 0;
11952   uint32_t insn;
11953   uint16_t insn16;
11954
11955   /* Target dependnet option.  */
11956   struct elf_nds32_link_hash_table *table;
11957   int load_store_relax;
11958   int relax_round;
11959
11960   relax_blank_list = NULL;
11961
11962   *again = FALSE;
11963
11964   /* Nothing to do for
11965    * relocatable link or
11966    * non-relocatable section or
11967    * non-code section or
11968    * empty content or
11969    * no reloc entry.  */
11970   if (link_info->relocatable
11971       || (sec->flags & SEC_RELOC) == 0
11972       || (sec->flags & SEC_EXCLUDE) == 1
11973       || (sec->flags & SEC_CODE) == 0
11974       || sec->size == 0)
11975     return TRUE;
11976
11977   /* 09.12.11 Workaround.  */
11978   /*  We have to adjust align for R_NDS32_LABEL if needed.
11979       The adjust approach only can fix 2-byte align once.  */
11980   if (sec->alignment_power > 2)
11981     return TRUE;
11982
11983   /* The optimization type to do.  */
11984
11985   table = nds32_elf_hash_table (link_info);
11986   relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11987   switch (relax_round)
11988     {
11989     case NDS32_RELAX_JUMP_IFC_ROUND:
11990       /* Here is the entrance of ifc jump relaxation.  */
11991       if (!nds32_elf_ifc_calc (link_info, abfd, sec))
11992         return FALSE;
11993       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
11994       return TRUE;
11995
11996     case NDS32_RELAX_EX9_BUILD_ROUND:
11997       /* Here is the entrance of ex9 relaxation.  There are two pass of
11998          ex9 relaxation.  The one is to traverse all instructions and build
11999          the hash table.  The other one is to compare instructions and replace
12000          it by ex9.it.  */
12001       if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
12002         return FALSE;
12003       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12004       return TRUE;
12005
12006     case NDS32_RELAX_EX9_REPLACE_ROUND:
12007       if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
12008         return FALSE;
12009       return TRUE;
12010
12011     case NDS32_RELAX_EMPTY_ROUND:
12012       nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12013       return TRUE;
12014
12015     case NDS32_RELAX_NORMAL_ROUND:
12016     default:
12017       if (sec->reloc_count == 0)
12018         return TRUE;
12019       break;
12020     }
12021
12022   /* The begining of general relaxation.  */
12023
12024   if (is_SDA_BASE_set == 0)
12025     {
12026       bfd_vma gp;
12027       is_SDA_BASE_set = 1;
12028       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12029                                 &gp, FALSE);
12030       relax_range_measurement (abfd);
12031     }
12032
12033   if (is_ITB_BASE_set == 0)
12034     {
12035       /* Set the _ITB_BASE_.  */
12036       if (!nds32_elf_ex9_itb_base (link_info))
12037         {
12038           (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"), abfd);
12039           bfd_set_error (bfd_error_bad_value);
12040         }
12041     }
12042
12043   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12044   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
12045   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12046                                                TRUE /* keep_memory */);
12047   if (internal_relocs == NULL)
12048     goto error_return;
12049
12050   irelend = internal_relocs + sec->reloc_count;
12051   irel = find_relocs_at_address (internal_relocs, internal_relocs,
12052                                  irelend, R_NDS32_RELAX_ENTRY);
12053
12054   if (irel == irelend)
12055     return TRUE;
12056
12057   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12058     {
12059       if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12060         {
12061           nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12062           return TRUE;
12063         }
12064
12065       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12066         optimize = 1;
12067
12068       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12069         opt_size = 1;
12070     }
12071
12072   load_store_relax = table->load_store_relax;
12073
12074   /* Get symbol table and section content.  */
12075   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12076       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12077     goto error_return;
12078
12079   /* Do relax loop only when finalize is not done.
12080      Take care of relaxable relocs except INSN16.  */
12081   for (irel = internal_relocs; irel < irelend; irel++)
12082     {
12083       int seq_len;              /* Original length of instruction sequence.  */
12084       int insn_len = 0;         /* Final length of instruction sequence.  */
12085       bfd_boolean removed;
12086
12087       insn = 0;
12088       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12089           && (irel->r_addend & 0x1f) >= 2)
12090         optimize = 1;
12091
12092       /* Relocation Types
12093          R_NDS32_LONGCALL1      53
12094          R_NDS32_LONGCALL2      54
12095          R_NDS32_LONGCALL3      55
12096          R_NDS32_LONGJUMP1      56
12097          R_NDS32_LONGJUMP2      57
12098          R_NDS32_LONGJUMP3      58
12099          R_NDS32_LOADSTORE      59  */
12100       if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12101           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12102         seq_len = GET_SEQ_LEN (irel->r_addend);
12103
12104       /* Relocation Types
12105          R_NDS32_LONGCALL4      107
12106          R_NDS32_LONGCALL5      108
12107          R_NDS32_LONGCALL6      109
12108          R_NDS32_LONGJUMP4      110
12109          R_NDS32_LONGJUMP5      111
12110          R_NDS32_LONGJUMP6      112
12111          R_NDS32_LONGJUMP7      113  */
12112       else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12113                && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12114         seq_len = 4;
12115
12116         /* Relocation Types
12117          R_NDS32_LO12S0_RELA            30
12118          R_NDS32_LO12S1_RELA            29
12119          R_NDS32_LO12S2_RELA            28
12120          R_NDS32_LO12S2_SP_RELA         71
12121          R_NDS32_LO12S2_DP_RELA         70
12122          R_NDS32_GOT_LO12               46
12123          R_NDS32_GOTOFF_LO12            50
12124          R_NDS32_PLTREL_LO12            65
12125          R_NDS32_PLT_GOTREL_LO12        67
12126          R_NDS32_17IFC_PCREL_RELA       96
12127          R_NDS32_GOT_SUFF               193
12128          R_NDS32_GOTOFF_SUFF            194
12129          R_NDS32_PLT_GOT_SUFF           195
12130          R_NDS32_MULCALL_SUFF           196
12131          R_NDS32_PTR                    197  */
12132       else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12133                 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12134                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12135                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12136                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12137                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12138                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12139                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12140                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12141                || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12142                    && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12143                || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12144                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12145                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12146                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
12147         seq_len = 0;
12148       else
12149         continue;
12150
12151       insn_len = seq_len;
12152       removed = FALSE;
12153
12154       switch (ELF32_R_TYPE (irel->r_info))
12155         {
12156         case R_NDS32_LONGCALL1:
12157           removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12158                                                &insn_len, contents, isymbuf,
12159                                                symtab_hdr);
12160           break;
12161         case R_NDS32_LONGCALL2:
12162           removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12163                                                &insn_len, contents, isymbuf,
12164                                                symtab_hdr);
12165           break;
12166         case R_NDS32_LONGCALL3:
12167           removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12168                                                &insn_len, contents, isymbuf,
12169                                                symtab_hdr);
12170           break;
12171         case R_NDS32_LONGJUMP1:
12172           removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12173                                                &insn_len, contents, isymbuf,
12174                                                symtab_hdr);
12175           break;
12176         case R_NDS32_LONGJUMP2:
12177           removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12178                                                &insn_len, contents, isymbuf,
12179                                                symtab_hdr);
12180           break;
12181         case R_NDS32_LONGJUMP3:
12182           removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12183                                                &insn_len, contents, isymbuf,
12184                                                symtab_hdr);
12185           break;
12186         case R_NDS32_LONGCALL4:
12187           removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12188                                                &insn_len, contents, isymbuf,
12189                                                symtab_hdr);
12190           break;
12191         case R_NDS32_LONGCALL5:
12192           removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12193                                                &insn_len, contents, isymbuf,
12194                                                symtab_hdr);
12195           break;
12196         case R_NDS32_LONGCALL6:
12197           removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12198                                                &insn_len, contents, isymbuf,
12199                                                symtab_hdr);
12200           break;
12201         case R_NDS32_LONGJUMP4:
12202           removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12203                                                &insn_len, contents, isymbuf,
12204                                                symtab_hdr);
12205           break;
12206         case R_NDS32_LONGJUMP5:
12207           removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12208                                                &insn_len, &seq_len, contents,
12209                                                isymbuf, symtab_hdr);
12210           break;
12211         case R_NDS32_LONGJUMP6:
12212           removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12213                                                &insn_len, &seq_len, contents,
12214                                                isymbuf, symtab_hdr);
12215           break;
12216         case R_NDS32_LONGJUMP7:
12217           removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12218                                                &insn_len, &seq_len, contents,
12219                                                isymbuf, symtab_hdr);
12220           break;
12221         case R_NDS32_LOADSTORE:
12222           removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12223                                                internal_relocs, &insn_len,
12224                                                contents, isymbuf, symtab_hdr,
12225                                                load_store_relax);
12226           break;
12227         case R_NDS32_LO12S0_RELA:
12228         case R_NDS32_LO12S1_RELA:
12229         case R_NDS32_LO12S2_DP_RELA:
12230         case R_NDS32_LO12S2_SP_RELA:
12231         case R_NDS32_LO12S2_RELA:
12232           /* Relax for low part.  */
12233           nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12234                                 contents, isymbuf, symtab_hdr);
12235
12236           /* It is impossible to delete blank, so just continue.  */
12237           continue;
12238         case R_NDS32_GOT_LO12:
12239         case R_NDS32_GOTOFF_LO12:
12240         case R_NDS32_PLTREL_LO12:
12241         case R_NDS32_PLT_GOTREL_LO12:
12242         case R_NDS32_GOTPC_LO12:
12243           /* Relax for PIC gp-relative low part.  */
12244           nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
12245                                    isymbuf, symtab_hdr);
12246
12247           /* It is impossible to delete blank, so just continue.  */
12248           continue;
12249         case R_NDS32_TLS_LE_LO12:
12250           /* Relax for LE TLS low part.  */
12251           nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
12252                                      isymbuf, symtab_hdr);
12253
12254           /* It is impossible to delete blank, so just continue.  */
12255           continue;
12256         case R_NDS32_TLS_LE_ADD:
12257           nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12258                                     contents, isymbuf, symtab_hdr, again);
12259           /* It is impossible to delete blank, so just continue.  */
12260           continue;
12261         case R_NDS32_TLS_LE_LS:
12262           nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12263                                    contents, isymbuf, symtab_hdr, again);
12264           continue;
12265         case R_NDS32_PTR:
12266           removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12267                                          &insn_len, &seq_len, contents);
12268           break;
12269         case R_NDS32_PLT_GOT_SUFF:
12270           nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12271                                        internal_relocs, contents,
12272                                        isymbuf, symtab_hdr, again);
12273           /* It is impossible to delete blank, so just continue.  */
12274           continue;
12275         case R_NDS32_GOT_SUFF:
12276           nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12277                                     internal_relocs, contents,
12278                                     symtab_hdr, again);
12279           /* It is impossible to delete blank, so just continue.  */
12280           continue;
12281         case R_NDS32_GOTOFF_SUFF:
12282           nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12283                                        internal_relocs, contents,
12284                                        isymbuf, symtab_hdr, again);
12285           /* It is impossible to delete blank, so just continue.  */
12286           continue;
12287         default:
12288           continue;
12289
12290         }
12291       if (removed && seq_len - insn_len > 0)
12292         {
12293           if (!insert_nds32_elf_blank
12294               (&relax_blank_list, irel->r_offset + insn_len,
12295                seq_len - insn_len))
12296             goto error_return;
12297           *again = TRUE;
12298         }
12299     }
12300
12301   calc_nds32_blank_total (relax_blank_list);
12302
12303   if (table->relax_fp_as_gp)
12304     {
12305       if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12306                                  irelend, isymbuf))
12307         goto error_return;
12308
12309       if (*again == FALSE)
12310         {
12311           if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12312                                                irelend))
12313             goto error_return;
12314         }
12315     }
12316
12317   nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12318
12319   if (*again == FALSE)
12320     {
12321       if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12322                                      &relax_blank_list, optimize, opt_size))
12323         goto error_return;
12324     }
12325
12326   /* It doesn't matter optimize_for_space_no_align anymore.
12327        If object file is assembled with flag '-Os',
12328        the we don't adjust jump-destination on 4-byte boundary.  */
12329
12330   if (relax_blank_list)
12331     {
12332       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12333       relax_blank_list = NULL;
12334     }
12335
12336   if (*again == FALSE)
12337     {
12338       /* Closing the section, so we don't relax it anymore.  */
12339       bfd_vma sec_size_align;
12340       Elf_Internal_Rela *tmp_rel;
12341
12342       /* Pad to alignment boundary.  Only handle current section alignment.  */
12343       sec_size_align = (sec->size + (~((-1) << sec->alignment_power)))
12344                        & ((-1) << sec->alignment_power);
12345       if ((sec_size_align - sec->size) & 0x2)
12346         {
12347           insn16 = NDS32_NOP16;
12348           bfd_putb16 (insn16, contents + sec->size);
12349           sec->size += 2;
12350         }
12351
12352       while (sec_size_align != sec->size)
12353         {
12354           insn = NDS32_NOP32;
12355           bfd_putb32 (insn, contents + sec->size);
12356           sec->size += 4;
12357         }
12358
12359       tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12360                                         irelend, R_NDS32_RELAX_ENTRY);
12361       if (tmp_rel != irelend)
12362         tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12363
12364       clean_nds32_elf_blank ();
12365     }
12366
12367 finish:
12368   if (internal_relocs != NULL
12369       && elf_section_data (sec)->relocs != internal_relocs)
12370     free (internal_relocs);
12371
12372   if (contents != NULL
12373       && elf_section_data (sec)->this_hdr.contents != contents)
12374     free (contents);
12375
12376   if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12377     free (isymbuf);
12378
12379   return result;
12380
12381 error_return:
12382   result = FALSE;
12383   goto finish;
12384 }
12385
12386 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12387 {
12388   {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12389   {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12390   {NULL, 0, 0, 0, 0}
12391 };
12392
12393 static bfd_boolean
12394 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12395                             struct bfd_link_info *info,
12396                             void *finfo ATTRIBUTE_UNUSED,
12397                             bfd_boolean (*func) (void *, const char *,
12398                                                  Elf_Internal_Sym *,
12399                                                  asection *,
12400                                                  struct elf_link_hash_entry *)
12401                             ATTRIBUTE_UNUSED)
12402 {
12403   FILE *sym_ld_script = NULL;
12404   struct elf_nds32_link_hash_table *table;
12405
12406   table = nds32_elf_hash_table (info);
12407   sym_ld_script = table->sym_ld_script;
12408
12409   if (check_start_export_sym)
12410     fprintf (sym_ld_script, "}\n");
12411
12412   return TRUE;
12413 }
12414
12415 static enum elf_reloc_type_class
12416 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12417                             const asection *rel_sec ATTRIBUTE_UNUSED,
12418                             const Elf_Internal_Rela *rela)
12419 {
12420   switch ((int) ELF32_R_TYPE (rela->r_info))
12421     {
12422     case R_NDS32_RELATIVE:
12423       return reloc_class_relative;
12424     case R_NDS32_JMP_SLOT:
12425       return reloc_class_plt;
12426     case R_NDS32_COPY:
12427       return reloc_class_copy;
12428     default:
12429       return reloc_class_normal;
12430     }
12431 }
12432
12433 /* Put target dependent option into info hash table.  */
12434 void
12435 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12436                                    int relax_fp_as_gp,
12437                                    int eliminate_gc_relocs,
12438                                    FILE * sym_ld_script, int load_store_relax,
12439                                    int target_optimize, int relax_status,
12440                                    int relax_round, FILE * ex9_export_file,
12441                                    FILE * ex9_import_file,
12442                                    int update_ex9_table, int ex9_limit,
12443                                    bfd_boolean ex9_loop_aware,
12444                                    bfd_boolean ifc_loop_aware)
12445 {
12446   struct elf_nds32_link_hash_table *table;
12447
12448   table = nds32_elf_hash_table (link_info);
12449   if (table == NULL)
12450     return;
12451
12452   table->relax_fp_as_gp = relax_fp_as_gp;
12453   table->eliminate_gc_relocs = eliminate_gc_relocs;
12454   table->sym_ld_script = sym_ld_script;
12455   table ->load_store_relax = load_store_relax;
12456   table->target_optimize = target_optimize;
12457   table->relax_status = relax_status;
12458   table->relax_round = relax_round;
12459   table->ex9_export_file = ex9_export_file;
12460   table->ex9_import_file = ex9_import_file;
12461   table->update_ex9_table = update_ex9_table;
12462   table->ex9_limit = ex9_limit;
12463   table->ex9_loop_aware = ex9_loop_aware;
12464   table->ifc_loop_aware = ifc_loop_aware;
12465 }
12466 \f
12467 /* These functions and data-structures are used for fp-as-gp
12468    optimization.  */
12469
12470 #define FAG_THRESHOLD   3       /* At least 3 gp-access.  */
12471 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12472    the read-only section and read-write section.  */
12473 #define FAG_WINDOW      (508 - 32)
12474
12475 /* An nds32_fag represent a gp-relative access.
12476    We find best fp-base by using a sliding window
12477    to find a base address which can cover most gp-access.  */
12478 struct nds32_fag
12479 {
12480   struct nds32_fag *next;       /* NULL-teminated linked list.  */
12481   bfd_vma addr;                 /* The address of this fag.  */
12482   Elf_Internal_Rela **relas;    /* The relocations associated with this fag.
12483                                    It is used for applying FP7U2_FLAG.  */
12484   int count;                    /* How many times this address is referred.
12485                                    There should be exactly `count' relocations
12486                                    in relas.  */
12487   int relas_capcity;            /* The buffer size of relas.
12488                                    We use an array instead of linked-list,
12489                                    and realloc is used to adjust buffer size.  */
12490 };
12491
12492 static void
12493 nds32_fag_init (struct nds32_fag *head)
12494 {
12495   memset (head, 0, sizeof (struct nds32_fag));
12496 }
12497
12498 static void
12499 nds32_fag_verify (struct nds32_fag *head)
12500 {
12501   struct nds32_fag *iter;
12502   struct nds32_fag *prev;
12503
12504   prev = NULL;
12505   iter = head->next;
12506   while (iter)
12507     {
12508       if (prev && prev->addr >= iter->addr)
12509         puts ("Bug in fp-as-gp insertion.");
12510       prev = iter;
12511       iter = iter->next;
12512     }
12513 }
12514
12515 /* Insert a fag in ascending order.
12516    If a fag of the same address already exists,
12517    they are chained by relas array.  */
12518
12519 static void
12520 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12521                   Elf_Internal_Rela * rel)
12522 {
12523   struct nds32_fag *iter;
12524   struct nds32_fag *new_fag;
12525   const int INIT_RELAS_CAP = 4;
12526
12527   for (iter = head;
12528        iter->next && iter->next->addr <= addr;
12529        iter = iter->next)
12530     /* Find somewhere to insert.  */ ;
12531
12532   /* `iter' will be equal to `head' if the list is empty.  */
12533   if (iter != head && iter->addr == addr)
12534     {
12535       /* The address exists in the list.
12536          Insert `rel' into relocation list, relas.  */
12537
12538       /* Check whether relas is big enough.  */
12539       if (iter->count >= iter->relas_capcity)
12540         {
12541           iter->relas_capcity *= 2;
12542           iter->relas = bfd_realloc
12543             (iter->relas, iter->relas_capcity * sizeof (void *));
12544         }
12545       iter->relas[iter->count++] = rel;
12546       return;
12547     }
12548
12549   /* This is a new address.  Create a fag node for it.  */
12550   new_fag = bfd_malloc (sizeof (struct nds32_fag));
12551   memset (new_fag, 0, sizeof (*new_fag));
12552   new_fag->addr = addr;
12553   new_fag->count = 1;
12554   new_fag->next = iter->next;
12555   new_fag->relas_capcity = INIT_RELAS_CAP;
12556   new_fag->relas = (Elf_Internal_Rela **)
12557     bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12558   new_fag->relas[0] = rel;
12559   iter->next = new_fag;
12560
12561   nds32_fag_verify (head);
12562 }
12563
12564 static void
12565 nds32_fag_free_list (struct nds32_fag *head)
12566 {
12567   struct nds32_fag *iter;
12568
12569   iter = head->next;
12570   while (iter)
12571     {
12572       struct nds32_fag *tmp = iter;
12573       iter = iter->next;
12574       free (tmp->relas);
12575       tmp->relas = NULL;
12576       free (tmp);
12577     }
12578 }
12579
12580 /* Find the best fp-base address.
12581    The relocation associated with that address is returned,
12582    so we can track the symbol instead of a fixed address.
12583
12584    When relaxation, the address of an datum may change,
12585    because a text section is shrinked, so the data section
12586    moves forward.  If the aligments of text and data section
12587    are different, their distance may change too.
12588    Therefore, tracking a fixed address is not appriate.  */
12589
12590 static int
12591 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12592 {
12593   struct nds32_fag *base;       /* First fag in the window.  */
12594   struct nds32_fag *last;       /* First fag outside the window.  */
12595   int accu = 0;                 /* Usage accumulation.  */
12596   struct nds32_fag *best;       /* Best fag.  */
12597   int baccu = 0;                /* Best accumulation.  */
12598
12599   /* Use first fag for initial, and find the last fag in the window.
12600
12601      In each iteration, we could simply subtract previous fag
12602      and accumulate following fags which are inside the window,
12603      untill we each the end.  */
12604
12605   if (head->next == NULL)
12606     {
12607       *bestpp = NULL;
12608       return 0;
12609     }
12610
12611   /* Initialize base.  */
12612   base = head->next;
12613   best = base;
12614   for (last = base;
12615        last && last->addr < base->addr + FAG_WINDOW;
12616        last = last->next)
12617     accu += last->count;
12618
12619   baccu = accu;
12620
12621   /* Record the best base in each iteration.  */
12622   while (base->next)
12623     {
12624       accu -= base->count;
12625       base = base->next;
12626       /* Account fags in window.  */
12627       for (/* Nothing.  */;
12628            last && last->addr < base->addr + FAG_WINDOW;
12629            last = last->next)
12630         accu += last->count;
12631
12632       /* A better fp-base?  */
12633       if (accu > baccu)
12634         {
12635           best = base;
12636           baccu = accu;
12637         }
12638     }
12639
12640   if (bestpp)
12641     *bestpp = best;
12642   return baccu;
12643 }
12644
12645 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12646    so we can convert it fo fp-relative access later.
12647    `best_fag' is the best fp-base.  Only those inside the window
12648    of best_fag is applied the flag.  */
12649
12650 static bfd_boolean
12651 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12652                       bfd *abfd, struct nds32_fag *best_fag,
12653                       Elf_Internal_Rela *internal_relocs,
12654                       Elf_Internal_Rela *irelend)
12655 {
12656   struct nds32_fag *ifag;
12657   bfd_vma best_fpbase, gp;
12658   bfd *output_bfd;
12659
12660   output_bfd = abfd->sections->output_section->owner;
12661   nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12662   best_fpbase = best_fag->addr;
12663
12664   if (best_fpbase > gp + sdata_range[1][1]
12665       || best_fpbase < gp - sdata_range[1][0])
12666     return FALSE;
12667
12668   /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12669      so we know they can be converted to lwi37.fp.   */
12670   for (ifag = best_fag;
12671        ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12672     {
12673       int i;
12674
12675       for (i = 0; i < ifag->count; i++)
12676         {
12677           Elf_Internal_Rela *insn16_rel;
12678           Elf_Internal_Rela *fag_rel;
12679
12680           fag_rel = ifag->relas[i];
12681
12682           /* Only if this is within the WINDOWS, FP7U2_FLAG
12683              is applied.  */
12684
12685           insn16_rel = find_relocs_at_address
12686             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12687
12688           if (insn16_rel != irelend)
12689             insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12690         }
12691     }
12692   return TRUE;
12693 }
12694
12695 /* Reset INSN16 to clean fp as gp.  */
12696
12697 static void
12698 nds32_fag_unmark_relax (struct nds32_fag *fag,
12699                         Elf_Internal_Rela *internal_relocs,
12700                         Elf_Internal_Rela *irelend)
12701 {
12702   struct nds32_fag *ifag;
12703   int i;
12704   Elf_Internal_Rela *insn16_rel;
12705   Elf_Internal_Rela *fag_rel;
12706
12707   for (ifag = fag; ifag; ifag = ifag->next)
12708     {
12709       for (i = 0; i < ifag->count; i++)
12710         {
12711           fag_rel = ifag->relas[i];
12712
12713           /* Restore the INSN16 relocation.  */
12714           insn16_rel = find_relocs_at_address
12715             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12716
12717           if (insn16_rel != irelend)
12718             insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12719         }
12720     }
12721 }
12722
12723 /* This is the main function of fp-as-gp optimization.
12724    It should be called by relax_section.  */
12725
12726 static bfd_boolean
12727 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12728                       bfd *abfd, asection *sec,
12729                       Elf_Internal_Rela *internal_relocs,
12730                       Elf_Internal_Rela *irelend,
12731                       Elf_Internal_Sym *isymbuf)
12732 {
12733   Elf_Internal_Rela *begin_rel = NULL;
12734   Elf_Internal_Rela *irel;
12735   struct nds32_fag fag_head;
12736   Elf_Internal_Shdr *symtab_hdr;
12737   bfd_byte *contents;
12738   bfd_boolean ifc_inside = FALSE;
12739
12740   /* FIXME: Can we bfd_elf_link_read_relocs for the relocs?  */
12741
12742   /* Per-function fp-base selection.
12743      1. Create a list for all the gp-relative access.
12744      2. Base on those gp-relative address,
12745         find a fp-base which can cover most access.
12746      3. Use the fp-base for fp-as-gp relaxation.
12747
12748      NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12749      we should
12750      1. delete the `la $fp, _FP_BASE_' instruction and
12751      2. not convert lwi.gp to lwi37.fp.
12752
12753      To delete the _FP_BASE_ instruction, we simply apply
12754      R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12755
12756      To suppress the conversion, we simply NOT to apply
12757      R_NDS32_INSN16_FP7U2_FLAG flag.  */
12758
12759   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12760
12761   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12762       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12763     return FALSE;
12764
12765   /* Check whether it is worth for fp-as-gp optimization,
12766      i.e., at least 3 gp-load.
12767
12768      Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12769      apply this optimization.  */
12770
12771   for (irel = internal_relocs; irel < irelend; irel++)
12772     {
12773       /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12774          One we enter the begin of the region, we track all the LW/ST
12775          instructions, so when we leave the region, we try to find
12776          the best fp-base address for those LW/ST instructions.  */
12777
12778       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12779           && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12780         {
12781           /* Begin of the region.  */
12782           if (begin_rel)
12783             (*_bfd_error_handler) (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12784
12785           begin_rel = irel;
12786           nds32_fag_init (&fag_head);
12787           ifc_inside = FALSE;
12788         }
12789       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12790                && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12791         {
12792           int accu;
12793           struct nds32_fag *best_fag, *tmp_fag;
12794           int dist;
12795
12796           /* End of the region.
12797              Check whether it is worth to do fp-as-gp.  */
12798
12799           if (begin_rel == NULL)
12800             {
12801               (*_bfd_error_handler) (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12802               continue;
12803             }
12804
12805           accu = nds32_fag_find_base (&fag_head, &best_fag);
12806
12807           /* Clean FP7U2_FLAG because they may set ever.  */
12808           tmp_fag = fag_head.next;
12809           nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12810
12811           /* Check if it is worth, and FP_BASE is near enough to SDA_BASE.  */
12812           if (accu < FAG_THRESHOLD
12813               || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12814                                         internal_relocs, irelend))
12815             {
12816               /* Not worth to do fp-as-gp.  */
12817               begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12818               begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12819               irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12820               irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12821               nds32_fag_free_list (&fag_head);
12822               begin_rel = NULL;
12823               continue;
12824             }
12825
12826           /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12827              so we use it to record the distance to the reloction of best
12828              fp-base.  */
12829           dist = best_fag->relas[0] - begin_rel;
12830           BFD_ASSERT (dist > 0 && dist < 0xffffff);
12831           /* Use high 16 bits of addend to record the _FP_BASE_ matched
12832              relocation.  And get the base value when relocating.  */
12833           begin_rel->r_addend &= (0x1 << 16) - 1;
12834           begin_rel->r_addend |= dist << 16;
12835
12836           nds32_fag_free_list (&fag_head);
12837           begin_rel = NULL;
12838         }
12839
12840       if (begin_rel == NULL || ifc_inside)
12841         /* Skip if we are not in the region of fp-as-gp.  */
12842         continue;
12843
12844       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12845           || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12846         {
12847           bfd_vma addr;
12848           uint32_t insn;
12849
12850           /* A gp-relative access is found.  Insert it to the fag-list.  */
12851
12852           /* Rt is necessary an RT3, so it can be converted to lwi37.fp.  */
12853           insn = bfd_getb32 (contents + irel->r_offset);
12854           if (!N32_IS_RT3 (insn))
12855             continue;
12856
12857           addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12858           nds32_fag_insert (&fag_head, addr, irel);
12859         }
12860       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12861         {
12862           begin_rel = NULL;
12863         }
12864       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12865                || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12866         {
12867           /* Suppress fp as gp when encounter ifc.  */
12868           ifc_inside = TRUE;
12869         }
12870     }
12871
12872   return TRUE;
12873 }
12874
12875 /* Remove unused `la $fp, _FD_BASE_' instruction.  */
12876
12877 static bfd_boolean
12878 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12879                                 Elf_Internal_Rela *internal_relocs,
12880                                 Elf_Internal_Rela *irelend)
12881 {
12882   Elf_Internal_Rela *irel;
12883   Elf_Internal_Shdr *symtab_hdr;
12884   bfd_byte *contents = NULL;
12885   nds32_elf_blank_t *relax_blank_list = NULL;
12886   bfd_boolean result = TRUE;
12887   bfd_boolean unused_region = FALSE;
12888
12889   /*
12890      NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12891      * R_NDS32_17IFC_PCREL_RELA
12892      * R_NDS32_10IFCU_PCREL_RELA
12893
12894      CASE??????????????
12895   */
12896
12897   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12898   nds32_get_section_contents (abfd, sec, &contents, TRUE);
12899
12900   for (irel = internal_relocs; irel < irelend; irel++)
12901     {
12902       /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12903          we marked to in previous pass.
12904          DO NOT scan relocations again, since we've alreadly decided it
12905          and set the flag.  */
12906       const char *syname;
12907       int syndx;
12908       uint32_t insn;
12909
12910       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12911           && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12912         unused_region = TRUE;
12913       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12914                && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12915         unused_region = FALSE;
12916
12917       /* We're not in the region.  */
12918       if (!unused_region)
12919         continue;
12920
12921       /* _FP_BASE_ must be a GLOBAL symbol.  */
12922       syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12923       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12924         continue;
12925
12926       /* The symbol name must be _FP_BASE_.  */
12927       syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12928       if (strcmp (syname, FP_BASE_NAME) != 0)
12929         continue;
12930
12931       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12932         {
12933           /* addi.gp  $fp, -256  */
12934           insn = bfd_getb32 (contents + irel->r_offset);
12935           if (insn != INSN_ADDIGP_TO_FP)
12936             continue;
12937         }
12938       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12939         {
12940           /* addi  $fp, $gp, -256  */
12941           insn = bfd_getb32 (contents + irel->r_offset);
12942           if (insn != INSN_ADDI_GP_TO_FP)
12943             continue;
12944         }
12945       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12946         {
12947           /* movi  $fp, FP_BASE  */
12948           insn = bfd_getb32 (contents + irel->r_offset);
12949           if (insn != INSN_MOVI_TO_FP)
12950             continue;
12951         }
12952       else
12953         continue;
12954
12955       /* We got here because a FP_BASE instruction is found.  */
12956       if (!insert_nds32_elf_blank_recalc_total
12957           (&relax_blank_list, irel->r_offset, 4))
12958         goto error_return;
12959     }
12960
12961 finish:
12962   if (relax_blank_list)
12963     {
12964       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12965       relax_blank_list = NULL;
12966     }
12967   return result;
12968
12969 error_return:
12970   result = FALSE;
12971   goto finish;
12972 }
12973
12974 /* This is a version of bfd_generic_get_relocated_section_contents.
12975    We need this variety because relaxation will modify the dwarf
12976    infomation.  When there is undefined symbol reference error mesage,
12977    linker need to dump line number where the symbol be used.  However
12978    the address is be relaxed, it can not get the original dwarf contents.
12979    The variety only modify function call for reading in the section.  */
12980
12981 static bfd_byte *
12982 nds32_elf_get_relocated_section_contents (bfd *abfd,
12983                                           struct bfd_link_info *link_info,
12984                                           struct bfd_link_order *link_order,
12985                                           bfd_byte *data,
12986                                           bfd_boolean relocatable,
12987                                           asymbol **symbols)
12988 {
12989   bfd *input_bfd = link_order->u.indirect.section->owner;
12990   asection *input_section = link_order->u.indirect.section;
12991   long reloc_size;
12992   arelent **reloc_vector;
12993   long reloc_count;
12994
12995   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12996   if (reloc_size < 0)
12997     return NULL;
12998
12999   /* Read in the section.  */
13000   if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13001     return NULL;
13002
13003   if (reloc_size == 0)
13004     return data;
13005
13006   reloc_vector = (arelent **) bfd_malloc (reloc_size);
13007   if (reloc_vector == NULL)
13008     return NULL;
13009
13010   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13011                                         reloc_vector, symbols);
13012   if (reloc_count < 0)
13013     goto error_return;
13014
13015   if (reloc_count > 0)
13016     {
13017       arelent **parent;
13018       for (parent = reloc_vector; *parent != NULL; parent++)
13019         {
13020           char *error_message = NULL;
13021           asymbol *symbol;
13022           bfd_reloc_status_type r;
13023
13024           symbol = *(*parent)->sym_ptr_ptr;
13025           if (symbol->section && discarded_section (symbol->section))
13026             {
13027               bfd_byte *p;
13028               static reloc_howto_type none_howto
13029                 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13030                          "unused", FALSE, 0, 0, FALSE);
13031
13032               p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
13033               _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
13034                                    p);
13035               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13036               (*parent)->addend = 0;
13037               (*parent)->howto = &none_howto;
13038               r = bfd_reloc_ok;
13039             }
13040           else
13041             r = bfd_perform_relocation (input_bfd, *parent, data,
13042                                         input_section,
13043                                         relocatable ? abfd : NULL,
13044                                         &error_message);
13045
13046           if (relocatable)
13047             {
13048               asection *os = input_section->output_section;
13049
13050               /* A partial link, so keep the relocs.  */
13051               os->orelocation[os->reloc_count] = *parent;
13052               os->reloc_count++;
13053             }
13054
13055           if (r != bfd_reloc_ok)
13056             {
13057               switch (r)
13058                 {
13059                 case bfd_reloc_undefined:
13060                   if (!((*link_info->callbacks->undefined_symbol)
13061                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13062                          input_bfd, input_section, (*parent)->address, TRUE)))
13063                     goto error_return;
13064                   break;
13065                 case bfd_reloc_dangerous:
13066                   BFD_ASSERT (error_message != NULL);
13067                   if (!((*link_info->callbacks->reloc_dangerous)
13068                         (link_info, error_message, input_bfd, input_section,
13069                          (*parent)->address)))
13070                     goto error_return;
13071                   break;
13072                 case bfd_reloc_overflow:
13073                   if (!((*link_info->callbacks->reloc_overflow)
13074                         (link_info, NULL,
13075                          bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13076                          (*parent)->howto->name, (*parent)->addend,
13077                          input_bfd, input_section, (*parent)->address)))
13078                     goto error_return;
13079                   break;
13080                 case bfd_reloc_outofrange:
13081                   /* PR ld/13730:
13082                      This error can result when processing some partially
13083                      complete binaries.  Do not abort, but issue an error
13084                      message instead.  */
13085                   link_info->callbacks->einfo
13086                     (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
13087                      abfd, input_section, * parent);
13088                   goto error_return;
13089
13090                 default:
13091                   abort ();
13092                   break;
13093                 }
13094             }
13095         }
13096     }
13097
13098   free (reloc_vector);
13099   return data;
13100
13101 error_return:
13102   free (reloc_vector);
13103   return NULL;
13104 }
13105 \f
13106 /* Link-time IFC relaxation.
13107    In this optimization, we chains jump instructions
13108    of the same destination with ifcall.  */
13109
13110
13111 /* List to save jal and j relocation.  */
13112 struct elf_nds32_ifc_symbol_entry
13113 {
13114   asection *sec;
13115   struct elf_link_hash_entry *h;
13116   struct elf_nds32_ifc_irel_list *irel_head;
13117   unsigned long insn;
13118   int times;
13119   int enable;           /* Apply ifc.  */
13120   int ex9_enable;       /* Apply ifc after ex9.  */
13121   struct elf_nds32_ifc_symbol_entry *next;
13122 };
13123
13124 struct elf_nds32_ifc_irel_list
13125 {
13126   Elf_Internal_Rela *irel;
13127   asection *sec;
13128   bfd_vma addr;
13129   /* If this is set, then it is the last instruction for
13130      ifc-chain, so it must be keep for the actual branching.  */
13131   int keep;
13132   struct elf_nds32_ifc_irel_list *next;
13133 };
13134
13135 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
13136
13137 /* Insert symbol of jal and j for ifc.  */
13138
13139 static void
13140 nds32_elf_ifc_insert_symbol (asection *sec,
13141                              struct elf_link_hash_entry *h,
13142                              Elf_Internal_Rela *irel,
13143                              unsigned long insn)
13144 {
13145   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13146
13147   /* Check there is target of existing entry the same as the new one.  */
13148   while (ptr != NULL)
13149     {
13150       if (((h == NULL && ptr->sec == sec
13151             && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
13152             && ptr->irel_head->irel->r_addend == irel->r_addend)
13153            || h != NULL)
13154           && ptr->h == h
13155           && ptr->insn == insn)
13156         {
13157           /* The same target exist, so insert into list.  */
13158           struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
13159
13160           while (irel_list->next != NULL)
13161             irel_list = irel_list->next;
13162           irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13163           irel_list = irel_list->next;
13164           irel_list->irel = irel;
13165           irel_list->keep = 1;
13166
13167           if (h == NULL)
13168             irel_list->sec = NULL;
13169           else
13170             irel_list->sec = sec;
13171           irel_list->next = NULL;
13172           return;
13173         }
13174       if (ptr->next == NULL)
13175         break;
13176       ptr = ptr->next;
13177     }
13178
13179   /* There is no same target entry, so build a new one.  */
13180   if (ifc_symbol_head == NULL)
13181     {
13182       ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13183       ptr = ifc_symbol_head;
13184     }
13185   else
13186     {
13187       ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13188       ptr = ptr->next;
13189     }
13190
13191   ptr->h = h;
13192   ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13193   ptr->irel_head->irel = irel;
13194   ptr->insn = insn;
13195   ptr->irel_head->keep = 1;
13196
13197   if (h == NULL)
13198     {
13199       /* Local symbols.  */
13200       ptr->sec = sec;
13201       ptr->irel_head->sec = NULL;
13202     }
13203   else
13204     {
13205       /* Global symbol.  */
13206       ptr->sec = NULL;
13207       ptr->irel_head->sec = sec;
13208     }
13209
13210   ptr->irel_head->next = NULL;
13211   ptr->times = 0;
13212   ptr->enable = 0;
13213   ptr->ex9_enable = 0;
13214   ptr->next = NULL;
13215 }
13216
13217 /* Gather all jal and j instructions.  */
13218
13219 static bfd_boolean
13220 nds32_elf_ifc_calc (struct bfd_link_info *info,
13221                     bfd *abfd, asection *sec)
13222 {
13223   Elf_Internal_Rela *internal_relocs;
13224   Elf_Internal_Rela *irelend;
13225   Elf_Internal_Rela *irel;
13226   Elf_Internal_Shdr *symtab_hdr;
13227   bfd_byte *contents = NULL;
13228   uint32_t insn, insn_with_reg;
13229   unsigned long r_symndx;
13230   struct elf_link_hash_entry *h;
13231   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
13232   struct elf_nds32_link_hash_table *table;
13233   bfd_boolean ifc_loop_aware;
13234
13235   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
13236                                                TRUE /* keep_memory */);
13237   irelend = internal_relocs + sec->reloc_count;
13238   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13239
13240   /* Check if the object enable ifc.  */
13241   irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
13242                                  R_NDS32_RELAX_ENTRY);
13243
13244   if (irel == NULL
13245       || irel >= irelend
13246       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
13247       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
13248           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
13249     return TRUE;
13250
13251   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
13252     return FALSE;
13253
13254   table = nds32_elf_hash_table (info);
13255   ifc_loop_aware = table->ifc_loop_aware;
13256   while (irel != NULL && irel < irelend)
13257     {
13258       /* Traverse all relocation and gather all of them to build the list.  */
13259
13260       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13261         {
13262           if (ifc_loop_aware == 1
13263               && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13264             {
13265               /* Check the region if loop or not.  If it is true and
13266                  ifc-loop-aware is true, ignore the region till region end.  */
13267               while (irel != NULL
13268                      && irel < irelend
13269                      && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13270                          || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13271                 irel++;
13272             }
13273         }
13274
13275       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13276         {
13277           insn = bfd_getb32 (contents + irel->r_offset);
13278           nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13279           r_symndx = ELF32_R_SYM (irel->r_info);
13280           if (r_symndx < symtab_hdr->sh_info)
13281             {
13282               /* Local symbol.  */
13283               nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13284             }
13285           else
13286             {
13287               /* External symbol.  */
13288               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13289               nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13290             }
13291         }
13292       irel++;
13293     }
13294   return TRUE;
13295 }
13296
13297 /* Determine whether j and jal should be substituted.  */
13298
13299 static void
13300 nds32_elf_ifc_filter (struct bfd_link_info *info)
13301 {
13302   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13303   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13304   struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13305   struct elf_nds32_link_hash_table *table;
13306   int target_optimize;
13307   bfd_vma address;
13308
13309   table = nds32_elf_hash_table (info);
13310   target_optimize = table->target_optimize;
13311   while (ptr)
13312     {
13313       irel_ptr = ptr->irel_head;
13314       if (ptr->h == NULL)
13315         {
13316           /* Local symbol.  */
13317           irel_keeper = irel_ptr;
13318           while (irel_ptr && irel_ptr->next)
13319             {
13320               /* Check there is jump target can be used.  */
13321               if ((irel_ptr->next->irel->r_offset
13322                    - irel_keeper->irel->r_offset) > 1022)
13323                 irel_keeper = irel_ptr->next;
13324               else
13325                 {
13326                   ptr->enable = 1;
13327                   irel_ptr->keep = 0;
13328                 }
13329               irel_ptr = irel_ptr->next;
13330             }
13331         }
13332       else
13333         {
13334           /* Global symbol.  */
13335           /* We have to get the absolute address and decide
13336              whether to keep it or not.  */
13337           while (irel_ptr)
13338             {
13339               address = (irel_ptr->irel->r_offset
13340                          + irel_ptr->sec->output_section->vma
13341                          + irel_ptr->sec->output_offset);
13342               irel_ptr->addr = address;
13343               irel_ptr = irel_ptr->next;
13344             }
13345
13346           irel_ptr = ptr->irel_head;
13347           while (irel_ptr)
13348             {
13349               /* Sort by address.  */
13350               struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13351               struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13352               struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13353               struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13354
13355               /* Get the smallest one.  */
13356               while (irel_temp->next)
13357                 {
13358                   if (irel_temp->next->addr < irel_dest->addr)
13359                     {
13360                       irel_dest_prev = irel_temp;
13361                       irel_dest = irel_temp->next;
13362                     }
13363                   irel_temp = irel_temp->next;
13364                 }
13365
13366               if (irel_dest != irel_ptr)
13367                 {
13368                   if (irel_ptr_prev)
13369                     irel_ptr_prev->next = irel_dest;
13370                   if (irel_dest_prev)
13371                     irel_dest_prev->next = irel_ptr;
13372                   irel_temp = irel_ptr->next;
13373                   irel_ptr->next = irel_dest->next;
13374                   irel_dest->next = irel_temp;
13375                 }
13376               irel_ptr_prev = irel_ptr;
13377               irel_ptr = irel_ptr->next;
13378             }
13379
13380           irel_ptr = ptr->irel_head;
13381           irel_keeper = irel_ptr;
13382           while (irel_ptr && irel_ptr->next)
13383             {
13384               if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13385                 irel_keeper = irel_ptr->next;
13386               else
13387                 {
13388                   ptr->enable = 1;
13389                   irel_ptr->keep = 0;
13390                 }
13391               irel_ptr = irel_ptr->next;
13392             }
13393         }
13394
13395         /* Ex9 enable.  Reserve it for ex9.  */
13396       if ((target_optimize & NDS32_RELAX_EX9_ON)
13397           && ptr->irel_head != irel_keeper)
13398         ptr->enable = 0;
13399       ptr = ptr->next;
13400     }
13401 }
13402
13403 /* Determine whether j and jal should be substituted after ex9 done.  */
13404
13405 static void
13406 nds32_elf_ifc_filter_after_ex9 (void)
13407 {
13408   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13409   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13410
13411   while (ptr)
13412     {
13413       if (ptr->enable == 0)
13414         {
13415           /* Check whether ifc is applied or not.  */
13416           irel_ptr = ptr->irel_head;
13417           ptr->ex9_enable = 1;
13418           while (irel_ptr)
13419             {
13420               if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13421                 {
13422                   /* Ex9 already.  */
13423                   ptr->ex9_enable = 0;
13424                   break;
13425                 }
13426               irel_ptr = irel_ptr->next;
13427             }
13428         }
13429       ptr = ptr->next;
13430     }
13431 }
13432
13433 /* Wrapper to do ifc relaxation.  */
13434
13435 bfd_boolean
13436 nds32_elf_ifc_finish (struct bfd_link_info *info)
13437 {
13438   int relax_status;
13439   struct elf_nds32_link_hash_table *table;
13440
13441   table = nds32_elf_hash_table (info);
13442   relax_status = table->relax_status;
13443
13444   if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13445     nds32_elf_ifc_filter (info);
13446   else
13447     nds32_elf_ifc_filter_after_ex9 ();
13448
13449   if (!nds32_elf_ifc_replace (info))
13450     return FALSE;
13451
13452   if (table)
13453     table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13454   return TRUE;
13455 }
13456
13457 /* Traverse the result of ifc filter and replace it with ifcall9.  */
13458
13459 static bfd_boolean
13460 nds32_elf_ifc_replace (struct bfd_link_info *info)
13461 {
13462   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13463   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13464   nds32_elf_blank_t *relax_blank_list = NULL;
13465   bfd_byte *contents = NULL;
13466   Elf_Internal_Rela *internal_relocs;
13467   Elf_Internal_Rela *irel;
13468   Elf_Internal_Rela *irelend;
13469   unsigned short insn16 = INSN_IFCALL9;
13470   struct elf_nds32_link_hash_table *table;
13471   int relax_status;
13472
13473   table = nds32_elf_hash_table (info);
13474   relax_status = table->relax_status;
13475
13476   while (ptr)
13477     {
13478       /* Traverse the ifc gather list, and replace the
13479          filter entries by ifcall9.  */
13480       if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13481           || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13482               && ptr->ex9_enable == 1))
13483         {
13484           irel_ptr = ptr->irel_head;
13485           if (ptr->h == NULL)
13486             {
13487               /* Local symbol.  */
13488               internal_relocs = _bfd_elf_link_read_relocs
13489                 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13490               irelend = internal_relocs + ptr->sec->reloc_count;
13491
13492               if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13493                                                &contents, TRUE))
13494                 return FALSE;
13495
13496               while (irel_ptr)
13497                 {
13498                   if (irel_ptr->keep == 0 && irel_ptr->next)
13499                     {
13500                       /* The one can be replaced.  We have to check whether
13501                          there is any alignment point in the region.  */
13502                       irel = irel_ptr->irel;
13503                       while (((irel_ptr->next->keep == 0
13504                                && irel < irel_ptr->next->irel)
13505                               || (irel_ptr->next->keep == 1 && irel < irelend))
13506                              && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13507                                   && (irel->r_addend & 0x1f) == 2))
13508                         irel++;
13509                       if (irel >= irelend
13510                           || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13511                                && (irel->r_addend & 0x1f) == 2
13512                                && ((irel->r_offset - get_nds32_elf_blank_total
13513                                     (&relax_blank_list, irel->r_offset, 1))
13514                                    & 0x02) == 0))
13515                         {
13516                           /* Replace by ifcall9.  */
13517                           bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13518                           if (!insert_nds32_elf_blank_recalc_total
13519                               (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13520                             return FALSE;
13521                           irel_ptr->irel->r_info =
13522                             ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13523                                           R_NDS32_10IFCU_PCREL_RELA);
13524                         }
13525                     }
13526                   irel_ptr = irel_ptr->next;
13527                 }
13528
13529               /* Delete the redundant code.  */
13530               if (relax_blank_list)
13531                 {
13532                   nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13533                                                  relax_blank_list);
13534                   relax_blank_list = NULL;
13535                 }
13536             }
13537           else
13538             {
13539               /* Global symbol.  */
13540               while (irel_ptr)
13541                 {
13542                   if (irel_ptr->keep == 0 && irel_ptr->next)
13543                     {
13544                       /* The one can be replaced, and we have to check
13545                          whether there is any alignment point in the region.  */
13546                       internal_relocs = _bfd_elf_link_read_relocs
13547                         (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13548                          TRUE /* keep_memory */);
13549                       irelend = internal_relocs + irel_ptr->sec->reloc_count;
13550                       if (!nds32_get_section_contents (irel_ptr->sec->owner,
13551                                                        irel_ptr->sec, &contents,
13552                                                        TRUE))
13553                         return FALSE;
13554
13555                       irel = irel_ptr->irel;
13556                       while (((irel_ptr->sec == irel_ptr->next->sec
13557                                && irel_ptr->next->keep == 0
13558                                && irel < irel_ptr->next->irel)
13559                               || ((irel_ptr->sec != irel_ptr->next->sec
13560                                    || irel_ptr->next->keep == 1)
13561                                   && irel < irelend))
13562                              && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13563                                   && (irel->r_addend & 0x1f) == 2))
13564                         irel++;
13565                       if (irel >= irelend
13566                           || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13567                                && (irel->r_addend & 0x1f) == 2
13568                                && ((irel->r_offset
13569                                     - get_nds32_elf_blank_total (&relax_blank_list,
13570                                                             irel->r_offset, 1)) & 0x02) == 0))
13571                         {
13572                           /* Replace by ifcall9.  */
13573                           bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13574                           if (!insert_nds32_elf_blank_recalc_total
13575                               (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13576                             return FALSE;
13577
13578                           /* Delete the redundant code, and clear the relocation.  */
13579                           nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13580                                                          irel_ptr->sec,
13581                                                          relax_blank_list);
13582                           irel_ptr->irel->r_info =
13583                             ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13584                                           R_NDS32_10IFCU_PCREL_RELA);
13585                           relax_blank_list = NULL;
13586                         }
13587                     }
13588
13589                   irel_ptr = irel_ptr->next;
13590                 }
13591             }
13592         }
13593       ptr = ptr->next;
13594     }
13595
13596   return TRUE;
13597 }
13598
13599 /* Relocate ifcall.  */
13600
13601 static bfd_boolean
13602 nds32_elf_ifc_reloc (void)
13603 {
13604   struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13605   struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13606   struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13607   bfd_vma relocation, address;
13608   unsigned short insn16;
13609   bfd_byte *contents = NULL;
13610   static bfd_boolean done = FALSE;
13611
13612   if (done)
13613     return TRUE;
13614
13615   done = TRUE;
13616
13617   while (ptr)
13618     {
13619       /* Check the entry is enable ifcall.  */
13620       if (ptr->enable == 1 || ptr->ex9_enable == 1)
13621         {
13622           /* Get the reserve jump.  */
13623           irel_ptr = ptr->irel_head;
13624           while (irel_ptr)
13625             {
13626               if (irel_ptr->keep == 1)
13627                 {
13628                   irel_keeper = irel_ptr;
13629                   break;
13630                 }
13631               irel_ptr = irel_ptr->next;
13632             }
13633
13634           irel_ptr = ptr->irel_head;
13635           if (ptr->h == NULL)
13636             {
13637               /* Local symbol.  */
13638               if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13639                                                &contents, TRUE))
13640                 return FALSE;
13641
13642               while (irel_ptr)
13643                 {
13644                   if (irel_ptr->keep == 0
13645                       && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13646                     {
13647                       relocation = irel_keeper->irel->r_offset;
13648                       relocation = relocation - irel_ptr->irel->r_offset;
13649                       while (irel_keeper && relocation > 1022)
13650                         {
13651                           irel_keeper = irel_keeper->next;
13652                           if (irel_keeper && irel_keeper->keep == 1)
13653                             {
13654                               relocation = irel_keeper->irel->r_offset;
13655                               relocation = relocation - irel_ptr->irel->r_offset;
13656                             }
13657                         }
13658                       if (relocation > 1022)
13659                         {
13660                           /* Double check.  */
13661                           irel_keeper = ptr->irel_head;
13662                           while (irel_keeper)
13663                             {
13664                               if (irel_keeper->keep == 1)
13665                                 {
13666                                   relocation = irel_keeper->irel->r_offset;
13667                                   relocation = relocation - irel_ptr->irel->r_offset;
13668                                 }
13669                               if (relocation <= 1022)
13670                                 break;
13671                               irel_keeper = irel_keeper->next;
13672                             }
13673                           if (!irel_keeper)
13674                             return FALSE;
13675                         }
13676                       irel_ptr->irel->r_info =
13677                         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13678                                       R_NDS32_NONE);
13679                       insn16 = INSN_IFCALL9 | (relocation >> 1);
13680                       bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13681                     }
13682                   irel_ptr = irel_ptr->next;
13683                 }
13684             }
13685           else
13686             {
13687               /* Global symbol.  */
13688               while (irel_ptr)
13689                 {
13690                   if (irel_ptr->keep == 0
13691                       && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13692                     {
13693                       /* Get the distance between ifcall and jump.  */
13694                       relocation = (irel_keeper->irel->r_offset
13695                                     + irel_keeper->sec->output_section->vma
13696                                     + irel_keeper->sec->output_offset);
13697                       address = (irel_ptr->irel->r_offset
13698                                  + irel_ptr->sec->output_section->vma
13699                                  + irel_ptr->sec->output_offset);
13700                       relocation = relocation - address;
13701
13702                       /* The distance is over ragne, find callee again.  */
13703                       while (irel_keeper && relocation > 1022)
13704                         {
13705                           irel_keeper = irel_keeper->next;
13706                           if (irel_keeper && irel_keeper->keep ==1)
13707                             {
13708                               relocation = (irel_keeper->irel->r_offset
13709                                             + irel_keeper->sec->output_section->vma
13710                                             + irel_keeper->sec->output_offset);
13711                               relocation = relocation - address;
13712                             }
13713                         }
13714
13715                       if (relocation > 1022)
13716                         {
13717                           /* Double check.  */
13718                           irel_keeper = ptr->irel_head;
13719                           while (irel_keeper)
13720                             {
13721                               if (irel_keeper->keep == 1)
13722                                 {
13723
13724                                   relocation = (irel_keeper->irel->r_offset
13725                                                 + irel_keeper->sec->output_section->vma
13726                                                 + irel_keeper->sec->output_offset);
13727                                   relocation = relocation - address;
13728                                 }
13729                               if (relocation <= 1022)
13730                                 break;
13731                               irel_keeper = irel_keeper->next;
13732                             }
13733                           if (!irel_keeper)
13734                             return FALSE;
13735                         }
13736                       if (!nds32_get_section_contents
13737                           (irel_ptr->sec->owner, irel_ptr->sec, &contents, TRUE))
13738                         return FALSE;
13739                       insn16 = INSN_IFCALL9 | (relocation >> 1);
13740                       bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13741                       irel_ptr->irel->r_info =
13742                         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13743                                       R_NDS32_NONE);
13744                     }
13745                   irel_ptr =irel_ptr->next;
13746                 }
13747             }
13748         }
13749       ptr = ptr->next;
13750     }
13751
13752   return TRUE;
13753 }
13754
13755 /* End of IFC relaxation.  */
13756 \f
13757 /* EX9 Instruction Table Relaxation.  */
13758
13759 /* Global hash list.  */
13760 struct elf_link_hash_entry_list
13761 {
13762   struct elf_link_hash_entry *h;
13763   struct elf_link_hash_entry_list *next;
13764 };
13765
13766 /* Save different destination but same insn.  */
13767 struct elf_link_hash_entry_mul_list
13768 {
13769   /* Global symbol times.  */
13770   int times;
13771   /* Save relocation for each global symbol but useful??  */
13772   Elf_Internal_Rela *irel;
13773   /* For sethi, two sethi may have the same high-part but different low-parts.  */
13774   Elf_Internal_Rela rel_backup;
13775   struct elf_link_hash_entry_list *h_list;
13776   struct elf_link_hash_entry_mul_list *next;
13777 };
13778
13779 /* Instruction hash table.  */
13780 struct elf_nds32_code_hash_entry
13781 {
13782   struct bfd_hash_entry root;
13783   int times;
13784   /* For insn that can use relocation or constant ex: sethi.  */
13785   int const_insn;
13786   asection *sec;
13787   struct elf_link_hash_entry_mul_list *m_list;
13788   /* Using r_addend.  */
13789   Elf_Internal_Rela *irel;
13790   /* Using r_info.  */
13791   Elf_Internal_Rela rel_backup;
13792 };
13793
13794 /* Instruction count list.  */
13795 struct elf_nds32_insn_times_entry
13796 {
13797   const char *string;
13798   int times;
13799   int order;
13800   asection *sec;
13801   struct elf_link_hash_entry_mul_list *m_list;
13802   Elf_Internal_Rela *irel;
13803   Elf_Internal_Rela rel_backup;
13804   struct elf_nds32_insn_times_entry *next;
13805 };
13806
13807 /* J and JAL symbol list.  */
13808 struct elf_nds32_symbol_entry
13809 {
13810   char *string;
13811   unsigned long insn;
13812   struct elf_nds32_symbol_entry *next;
13813 };
13814
13815 /* Relocation list.  */
13816 struct elf_nds32_irel_entry
13817 {
13818   Elf_Internal_Rela *irel;
13819   struct elf_nds32_irel_entry *next;
13820 };
13821
13822 /* ex9.it insn need to be fixed.  */
13823 struct elf_nds32_ex9_refix
13824 {
13825   Elf_Internal_Rela *irel;
13826   asection *sec;
13827   struct elf_link_hash_entry *h;
13828   int order;
13829   struct elf_nds32_ex9_refix *next;
13830 };
13831
13832 static struct bfd_hash_table ex9_code_table;
13833 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13834 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13835
13836 /* EX9 hash function.  */
13837
13838 static struct bfd_hash_entry *
13839 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13840                              struct bfd_hash_table *table,
13841                              const char *string)
13842 {
13843   struct elf_nds32_code_hash_entry *ret;
13844
13845   /* Allocate the structure if it has not already been allocated by a
13846      subclass.  */
13847   if (entry == NULL)
13848     {
13849       entry = (struct bfd_hash_entry *)
13850         bfd_hash_allocate (table, sizeof (*ret));
13851       if (entry == NULL)
13852         return entry;
13853     }
13854
13855   /* Call the allocation method of the superclass.  */
13856   entry = bfd_hash_newfunc (entry, table, string);
13857   if (entry == NULL)
13858     return entry;
13859
13860   ret = (struct elf_nds32_code_hash_entry*) entry;
13861   ret->times = 0;
13862   ret->const_insn = 0;
13863   ret->m_list = NULL;
13864   ret->sec = NULL;
13865   ret->irel = NULL;
13866   return &ret->root;
13867 }
13868
13869 /* Insert ex9 entry
13870    this insert must be stable sorted by times.  */
13871
13872 static void
13873 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13874 {
13875   struct elf_nds32_insn_times_entry *temp;
13876   struct elf_nds32_insn_times_entry *temp2;
13877
13878   if (ex9_insn_head == NULL)
13879     {
13880       ex9_insn_head = ptr;
13881       ptr->next = NULL;
13882     }
13883   else
13884     {
13885       temp = ex9_insn_head;
13886       temp2 = ex9_insn_head;
13887       while (temp->next &&
13888              (temp->next->times >= ptr->times
13889               || temp->times == -1))
13890         {
13891           if (temp->times == -1)
13892             temp2 = temp;
13893           temp = temp->next;
13894         }
13895       if (ptr->times > temp->times && temp->times != -1)
13896         {
13897           ptr->next = temp;
13898           if (temp2->times == -1)
13899             temp2->next = ptr;
13900           else
13901             ex9_insn_head = ptr;
13902         }
13903       else if (temp->next == NULL)
13904         {
13905           temp->next = ptr;
13906           ptr->next = NULL;
13907         }
13908       else
13909         {
13910           ptr->next = temp->next;
13911           temp->next = ptr;
13912         }
13913     }
13914 }
13915
13916 /* Examine each insn times in hash table.
13917    Handle multi-link hash entry.
13918
13919    TODO: This function doesn't assign so much info since it is fake.  */
13920
13921 static int
13922 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13923 {
13924   struct elf_nds32_insn_times_entry *ptr;
13925   int times;
13926
13927   if (h->m_list == NULL)
13928     {
13929       /* Local symbol insn or insn without relocation.  */
13930       if (h->times < 3)
13931         return TRUE;
13932
13933       ptr = (struct elf_nds32_insn_times_entry *)
13934         bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13935       ptr->times = h->times;
13936       ptr->string = h->root.string;
13937       ptr->m_list = NULL;
13938       ptr->sec = h->sec;
13939       ptr->irel = h->irel;
13940       ptr->rel_backup = h->rel_backup;
13941       nds32_elf_ex9_insert_entry (ptr);
13942     }
13943   else
13944     {
13945       /* Global symbol insn.  */
13946       /* Only sethi insn has multiple m_list.  */
13947       struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13948
13949       times = 0;
13950       while (m_list)
13951         {
13952           times += m_list->times;
13953           m_list = m_list->next;
13954         }
13955       if (times >= 3)
13956         {
13957           m_list = h->m_list;
13958           ptr = (struct elf_nds32_insn_times_entry *)
13959             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13960           ptr->times = times; /* Use the total times.  */
13961           ptr->string = h->root.string;
13962           ptr->m_list = m_list;
13963           ptr->sec = h->sec;
13964           ptr->irel = m_list->irel;
13965           ptr->rel_backup = m_list->rel_backup;
13966           nds32_elf_ex9_insert_entry (ptr);
13967         }
13968       if (h->const_insn == 1)
13969         {
13970           /* sethi with constant value.  */
13971           if (h->times < 3)
13972             return TRUE;
13973
13974           ptr = (struct elf_nds32_insn_times_entry *)
13975             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13976           ptr->times = h->times;
13977           ptr->string = h->root.string;
13978           ptr->m_list = NULL;
13979           ptr->sec = NULL;
13980           ptr->irel = NULL;
13981           ptr->rel_backup = h->rel_backup;
13982           nds32_elf_ex9_insert_entry (ptr);
13983         }
13984     }
13985   return TRUE;
13986 }
13987
13988 /* Count each insn times in hash table.
13989    Handle multi-link hash entry.  */
13990
13991 static int
13992 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13993 {
13994   int reservation, times;
13995   unsigned long relocation, min_relocation;
13996   struct elf_nds32_insn_times_entry *ptr;
13997
13998   if (h->m_list == NULL)
13999     {
14000       /* Local symbol insn or insn without relocation.  */
14001       if (h->times < 3)
14002         return TRUE;
14003       ptr = (struct elf_nds32_insn_times_entry *)
14004         bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14005       ptr->times = h->times;
14006       ptr->string = h->root.string;
14007       ptr->m_list = NULL;
14008       ptr->sec = h->sec;
14009       ptr->irel = h->irel;
14010       ptr->rel_backup = h->rel_backup;
14011       nds32_elf_ex9_insert_entry (ptr);
14012     }
14013   else
14014     {
14015       /* Global symbol insn.  */
14016       /* Only sethi insn has multiple m_list.  */
14017       struct elf_link_hash_entry_mul_list *m_list = h->m_list;
14018
14019       if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
14020           && m_list->next != NULL)
14021         {
14022           /* Sethi insn has different symbol or addend but has same hi20.  */
14023           times = 0;
14024           reservation = 1;
14025           relocation = 0;
14026           min_relocation = 0xffffffff;
14027           while (m_list)
14028             {
14029               /* Get the minimum sethi address
14030                  and calculate how many entry the sethi-list have to use.  */
14031               if ((m_list->h_list->h->root.type == bfd_link_hash_defined
14032                    || m_list->h_list->h->root.type == bfd_link_hash_defweak)
14033                   && (m_list->h_list->h->root.u.def.section != NULL
14034                       && m_list->h_list->h->root.u.def.section->output_section != NULL))
14035                 {
14036                   relocation = (m_list->h_list->h->root.u.def.value +
14037                                 m_list->h_list->h->root.u.def.section->output_section->vma +
14038                                 m_list->h_list->h->root.u.def.section->output_offset);
14039                   relocation += m_list->irel->r_addend;
14040                 }
14041               else
14042                 relocation = 0;
14043               if (relocation < min_relocation)
14044                 min_relocation = relocation;
14045               times += m_list->times;
14046               m_list = m_list->next;
14047             }
14048           if (min_relocation < ex9_relax_size)
14049             reservation = (min_relocation >> 12) + 1;
14050           else
14051             reservation = (min_relocation >> 12)
14052                           - ((min_relocation - ex9_relax_size) >> 12) + 1;
14053           if (reservation < (times / 3))
14054             {
14055               /* Efficient enough to use ex9.  */
14056               int i;
14057
14058               for (i = reservation ; i > 0; i--)
14059                 {
14060                   /* Allocate number of reservation ex9 entry.  */
14061                   ptr = (struct elf_nds32_insn_times_entry *)
14062                     bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14063                   ptr->times = h->m_list->times / reservation;
14064                   ptr->string = h->root.string;
14065                   ptr->m_list = h->m_list;
14066                   ptr->sec = h->sec;
14067                   ptr->irel = h->m_list->irel;
14068                   ptr->rel_backup = h->m_list->rel_backup;
14069                   nds32_elf_ex9_insert_entry (ptr);
14070                 }
14071             }
14072         }
14073       else
14074         {
14075           /* Normal global symbol that means no different address symbol
14076              using same ex9 entry.  */
14077           if (m_list->times >= 3)
14078             {
14079               ptr = (struct elf_nds32_insn_times_entry *)
14080                 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14081               ptr->times = m_list->times;
14082               ptr->string = h->root.string;
14083               ptr->m_list = h->m_list;
14084               ptr->sec = h->sec;
14085               ptr->irel = h->m_list->irel;
14086               ptr->rel_backup = h->m_list->rel_backup;
14087               nds32_elf_ex9_insert_entry (ptr);
14088             }
14089         }
14090
14091       if (h->const_insn == 1)
14092         {
14093           /* sethi with constant value.  */
14094           if (h->times < 3)
14095             return TRUE;
14096
14097           ptr = (struct elf_nds32_insn_times_entry *)
14098             bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14099           ptr->times = h->times;
14100           ptr->string = h->root.string;
14101           ptr->m_list = NULL;
14102           ptr->sec = NULL;
14103           ptr->irel = NULL;
14104           ptr->rel_backup = h->rel_backup;
14105           nds32_elf_ex9_insert_entry (ptr);
14106         }
14107     }
14108
14109   return TRUE;
14110 }
14111
14112 /* Hash table traverse function.  */
14113
14114 static void
14115 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
14116 {
14117   unsigned int i;
14118
14119   ex9_code_table.frozen = 1;
14120   for (i = 0; i < ex9_code_table.size; i++)
14121     {
14122       struct bfd_hash_entry *p;
14123
14124       for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
14125         if (!func ((struct elf_nds32_code_hash_entry *) p))
14126           goto out;
14127     }
14128 out:
14129   ex9_code_table.frozen = 0;
14130 }
14131
14132
14133 /* Give order number to insn list.  */
14134
14135 static void
14136 nds32_elf_order_insn_times (struct bfd_link_info *info)
14137 {
14138   struct elf_nds32_insn_times_entry *ex9_insn;
14139   struct elf_nds32_insn_times_entry *temp = NULL;
14140   struct elf_nds32_link_hash_table *table;
14141   int ex9_limit;
14142   int number = 0;
14143
14144   if (ex9_insn_head == NULL)
14145     return;
14146
14147 /* The max number of entries is 512.  */
14148   ex9_insn = ex9_insn_head;
14149   table = nds32_elf_hash_table (info);
14150   ex9_limit = table->ex9_limit;
14151
14152   ex9_insn = ex9_insn_head;
14153
14154   while (ex9_insn != NULL && number < ex9_limit)
14155     {
14156       ex9_insn->order = number;
14157       number++;
14158       temp = ex9_insn;
14159       ex9_insn = ex9_insn->next;
14160     }
14161
14162   if (ex9_insn && temp)
14163     temp->next = NULL;
14164
14165   while (ex9_insn != NULL)
14166     {
14167       /* Free useless entry.  */
14168       temp = ex9_insn;
14169       ex9_insn = ex9_insn->next;
14170       free (temp);
14171     }
14172 }
14173
14174 /* Build .ex9.itable section.  */
14175
14176 static void
14177 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
14178 {
14179   asection *table_sec;
14180   struct elf_nds32_insn_times_entry *ptr;
14181   bfd *it_abfd;
14182   int number = 0;
14183   bfd_byte *contents = NULL;
14184
14185   for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14186        it_abfd = it_abfd->link.next)
14187     {
14188       /* Find the section .ex9.itable, and put all entries into it.  */
14189       table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14190       if (table_sec != NULL)
14191         {
14192           if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
14193             return;
14194
14195           for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14196             number++;
14197
14198           table_sec->size = number * 4;
14199
14200           if (number == 0)
14201             return;
14202
14203           elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
14204           number = 0;
14205           for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14206             {
14207               long val;
14208
14209               val = strtol (ptr->string, NULL, 16);
14210               bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
14211               number++;
14212             }
14213           break;
14214         }
14215     }
14216 }
14217
14218 /* Get insn with regs according to relocation type.  */
14219
14220 static void
14221 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
14222                              uint32_t insn, uint32_t *insn_with_reg)
14223 {
14224   reloc_howto_type *howto = NULL;
14225
14226   if (irel == NULL
14227       || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14228           && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14229              >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14230     {
14231       *insn_with_reg = insn;
14232       return;
14233     }
14234
14235   howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14236   *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
14237 }
14238
14239 /* Mask number of address bits according to relocation.  */
14240
14241 static unsigned long
14242 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
14243 {
14244   reloc_howto_type *howto = NULL;
14245
14246   if (irel == NULL
14247       || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14248           && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14249              >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14250     return 0;
14251
14252   howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14253   return howto->dst_mask;
14254 }
14255
14256 static void
14257 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14258                              struct elf_nds32_irel_entry *irel_ptr)
14259 {
14260   if (*irel_list == NULL)
14261     {
14262       *irel_list = irel_ptr;
14263       irel_ptr->next = NULL;
14264     }
14265   else
14266     {
14267       irel_ptr->next = *irel_list;
14268       *irel_list = irel_ptr;
14269     }
14270 }
14271
14272 static void
14273 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14274                           struct elf_link_hash_entry *h, int order)
14275 {
14276   struct elf_nds32_ex9_refix *ptr;
14277
14278   ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14279   ptr->sec = sec;
14280   ptr->irel = irel;
14281   ptr->h = h;
14282   ptr->order = order;
14283   ptr->next = NULL;
14284
14285   if (ex9_refix_head == NULL)
14286     ex9_refix_head = ptr;
14287   else
14288     {
14289       struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14290
14291       while (temp->next != NULL)
14292         temp = temp->next;
14293       temp->next = ptr;
14294     }
14295 }
14296
14297 enum
14298 {
14299   DATA_EXIST = 1,
14300   CLEAN_PRE = 1 << 1,
14301   PUSH_PRE = 1 << 2
14302 };
14303
14304 /* Check relocation type if supporting for ex9.  */
14305
14306 static int
14307 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14308                                 Elf_Internal_Rela **irel,
14309                                 Elf_Internal_Rela *irelend,
14310                                 nds32_elf_blank_t *relax_blank_list,
14311                                 asection *sec,bfd_vma *off,
14312                                 bfd_byte *contents)
14313 {
14314   /* Suppress ex9 if `.no_relax ex9' or inner loop.  */
14315   bfd_boolean nested_ex9, nested_loop;
14316   bfd_boolean ex9_loop_aware;
14317   /* We use the highest 1 byte of result to record
14318      how many bytes location counter has to move.  */
14319   int result = 0;
14320   Elf_Internal_Rela *irel_save = NULL;
14321   struct elf_nds32_link_hash_table *table;
14322
14323   table = nds32_elf_hash_table (info);
14324   ex9_loop_aware = table->ex9_loop_aware;
14325
14326   while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14327     {
14328       switch (ELF32_R_TYPE ((*irel)->r_info))
14329         {
14330         case R_NDS32_RELAX_REGION_BEGIN:
14331           /* Ignore code block.  */
14332           nested_ex9 = FALSE;
14333           nested_loop = FALSE;
14334           if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14335               || (ex9_loop_aware
14336                   && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14337             {
14338               /* Check the region if loop or not.  If it is true and
14339                  ex9-loop-aware is true, ignore the region till region end.  */
14340               /* To save the status for in .no_relax ex9 region and
14341                  loop region to conform the block can do ex9 relaxation.  */
14342               nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14343               nested_loop = (ex9_loop_aware
14344                              && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14345               while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14346                 {
14347                   (*irel)++;
14348                   if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14349                     {
14350                       /* There may be nested region.  */
14351                       if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14352                         nested_ex9 = TRUE;
14353                       else if (ex9_loop_aware
14354                                && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14355                         nested_loop = TRUE;
14356                     }
14357                   else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14358                     {
14359                       /* The end of region.  */
14360                       if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14361                         nested_ex9 = FALSE;
14362                       else if (ex9_loop_aware
14363                                && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14364                         nested_loop = FALSE;
14365                     }
14366                   else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14367                            && ((*irel)->r_addend & 0x1f) == 2)
14368                     {
14369                       /* Alignment exist in the region.  */
14370                       result |= CLEAN_PRE;
14371                       if (((*irel)->r_offset -
14372                            get_nds32_elf_blank_total (&relax_blank_list,
14373                                                       (*irel)->r_offset, 0)) & 0x02)
14374                         result |= PUSH_PRE;
14375                     }
14376                 }
14377               if ((*irel) >= irelend)
14378                 *off = sec->size;
14379               else
14380                 *off = (*irel)->r_offset;
14381
14382               /* The final instruction in the region, regard this one as data to ignore it.  */
14383               result |= DATA_EXIST;
14384               return result;
14385             }
14386           break;
14387
14388         case R_NDS32_LABEL:
14389           if (((*irel)->r_addend & 0x1f) == 2)
14390             {
14391               /* Check this point is align and decide to do ex9 or not.  */
14392               result |= CLEAN_PRE;
14393               if (((*irel)->r_offset -
14394                    get_nds32_elf_blank_total (&relax_blank_list,
14395                                               (*irel)->r_offset, 0)) & 0x02)
14396                 result |= PUSH_PRE;
14397             }
14398           break;
14399         case R_NDS32_32_RELA:
14400           /* Data.  */
14401           result |= (4 << 24);
14402           result |= DATA_EXIST;
14403           break;
14404         case R_NDS32_16_RELA:
14405           /* Data.  */
14406           result |= (2 << 24);
14407           result |= DATA_EXIST;
14408           break;
14409         case R_NDS32_DATA:
14410           /* Data.  */
14411           /* The least code alignment is 2.  If the data is only one byte,
14412              we have to shift one more byte.  */
14413           if ((*irel)->r_addend == 1)
14414             result |= ((*irel)->r_addend << 25) ;
14415           else
14416             result |= ((*irel)->r_addend << 24) ;
14417
14418           result |= DATA_EXIST;
14419           break;
14420
14421         case R_NDS32_25_PCREL_RELA:
14422         case R_NDS32_SDA16S3_RELA:
14423         case R_NDS32_SDA15S3_RELA:
14424         case R_NDS32_SDA15S3:
14425         case R_NDS32_SDA17S2_RELA:
14426         case R_NDS32_SDA15S2_RELA:
14427         case R_NDS32_SDA12S2_SP_RELA:
14428         case R_NDS32_SDA12S2_DP_RELA:
14429         case R_NDS32_SDA15S2:
14430         case R_NDS32_SDA18S1_RELA:
14431         case R_NDS32_SDA15S1_RELA:
14432         case R_NDS32_SDA15S1:
14433         case R_NDS32_SDA19S0_RELA:
14434         case R_NDS32_SDA15S0_RELA:
14435         case R_NDS32_SDA15S0:
14436         case R_NDS32_HI20_RELA:
14437         case R_NDS32_LO12S0_ORI_RELA:
14438         case R_NDS32_LO12S0_RELA:
14439         case R_NDS32_LO12S1_RELA:
14440         case R_NDS32_LO12S2_RELA:
14441           /* These relocation is supported ex9 relaxation currently.  */
14442           /* We have to save the relocation for using later, since we have
14443              to check there is any alignment in the same address.  */
14444           irel_save = *irel;
14445           break;
14446         default:
14447           /* Not support relocations.  */
14448           if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14449               && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14450               && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14451             {
14452               /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14453                  But we have to consider if there is any side-effect.  */
14454               if (!(result & DATA_EXIST))
14455                 {
14456                   /* We have to confirm there is no data relocation in the
14457                      same address.  In general case, this won't happen.  */
14458                   /* We have to do ex9 conservative, for those relocation not
14459                      considerd we ignore instruction.  */
14460                   result |= DATA_EXIST;
14461                   if (*(contents + *off) & 0x80)
14462                     result |= (2 << 24);
14463                   else
14464                     result |= (4 << 24);
14465                   break;
14466                 }
14467             }
14468         }
14469       if ((*irel) < irelend
14470           && ((*irel) + 1) < irelend
14471           && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14472         /* There are relocations pointing to the same address, we have to
14473            check all of them.  */
14474         (*irel)++;
14475       else
14476         {
14477           if (irel_save)
14478             *irel = irel_save;
14479           return result;
14480         }
14481     }
14482   return result;
14483 }
14484
14485 /* Replace with ex9 instruction.  */
14486
14487 static bfd_boolean
14488 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14489                          nds32_elf_blank_t **relax_blank_list,
14490                          struct elf_nds32_irel_entry *pre_irel_ptr,
14491                          struct elf_nds32_irel_entry **irel_list)
14492 {
14493   if (insn16 != 0)
14494     {
14495       /* Implement the ex9 relaxation.  */
14496       bfd_putb16 (insn16, contents + pre_off);
14497       if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14498                                                 pre_off + 2, 2))
14499         return FALSE;
14500       if (pre_irel_ptr != NULL)
14501         nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14502     }
14503   return TRUE;
14504 }
14505
14506 /* Replace input file instruction which is in ex9 itable.  */
14507
14508 static bfd_boolean
14509 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14510 {
14511   struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14512   bfd_byte *contents = NULL;
14513   bfd_vma off;
14514   uint16_t insn16, insn_ex9;
14515   /* `pre_*' are used to track previous instruction that can use ex9.it.  */
14516   bfd_vma pre_off = -1;
14517   uint16_t pre_insn16 = 0;
14518   struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14519   Elf_Internal_Rela *internal_relocs;
14520   Elf_Internal_Rela *irel;
14521   Elf_Internal_Rela *irelend;
14522   Elf_Internal_Shdr *symtab_hdr;
14523   Elf_Internal_Sym *isym = NULL;
14524   nds32_elf_blank_t *relax_blank_list = NULL;
14525   uint32_t insn = 0;
14526   uint32_t insn_with_reg = 0;
14527   uint32_t it_insn;
14528   uint32_t it_insn_with_reg;
14529   unsigned long r_symndx;
14530   asection *isec;
14531   struct elf_nds32_irel_entry *irel_list = NULL;
14532   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14533   int data_flag, do_replace, save_irel;
14534   struct elf_link_hash_entry_list *h_list;
14535
14536
14537   /* Load section instructions, relocations, and symbol table.  */
14538   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
14539       || !nds32_get_local_syms (abfd, sec, &isym))
14540     return FALSE;
14541   internal_relocs =
14542     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14543   irelend = internal_relocs + sec->reloc_count;
14544   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14545
14546   off = 0;
14547
14548   /* Check if the object enable ex9.  */
14549   irel = find_relocs_at_address (internal_relocs, internal_relocs,
14550                                  irelend, R_NDS32_RELAX_ENTRY);
14551
14552   /* Check this section trigger ex9 relaxation.  */
14553   if (irel == NULL
14554       || irel >= irelend
14555       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14556       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14557           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14558     return TRUE;
14559
14560   irel = internal_relocs;
14561
14562   /* Check alignment and fetch proper relocation.  */
14563   while (off < sec->size)
14564     {
14565       struct elf_link_hash_entry *h = NULL;
14566       struct elf_nds32_irel_entry *irel_ptr = NULL;
14567
14568       /* Syn the instruction and the relocation.  */
14569       while (irel != NULL && irel < irelend && irel->r_offset < off)
14570         irel++;
14571
14572       data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14573                                                   relax_blank_list, sec,
14574                                                   &off, contents);
14575       if (data_flag & PUSH_PRE)
14576         if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14577                                       &relax_blank_list, pre_irel_ptr,
14578                                       &irel_list))
14579           return FALSE;
14580
14581       if (data_flag & CLEAN_PRE)
14582         {
14583           pre_off = 0;
14584           pre_insn16 = 0;
14585           pre_irel_ptr = NULL;
14586         }
14587       if (data_flag & DATA_EXIST)
14588         {
14589           /* We save the move offset in the highest byte.  */
14590           off += (data_flag >> 24);
14591           continue;
14592         }
14593
14594       if (*(contents + off) & 0x80)
14595         {
14596           /* 2-byte instruction.  */
14597           off += 2;
14598           continue;
14599         }
14600
14601       /* Load the instruction and its opcode with register for comparing.  */
14602       ex9_insn = ex9_insn_head;
14603       insn = bfd_getb32 (contents + off);
14604       insn_with_reg = 0;
14605       while (ex9_insn)
14606         {
14607           it_insn = strtol (ex9_insn->string, NULL, 16);
14608           it_insn_with_reg = 0;
14609           do_replace = 0;
14610           save_irel = 0;
14611
14612           if (irel != NULL && irel < irelend && irel->r_offset == off)
14613             {
14614               /* Insn with relocation.  */
14615               nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14616
14617               if (ex9_insn->irel != NULL)
14618                 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14619                                              &it_insn_with_reg);
14620
14621               if (ex9_insn->irel != NULL
14622                   && (ELF32_R_TYPE (irel->r_info) ==
14623                       ELF32_R_TYPE (ex9_insn->irel->r_info))
14624                   && (insn_with_reg == it_insn_with_reg))
14625                 {
14626                   /* Insn relocation and format is the same as table entry.  */
14627
14628                   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14629                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14630                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14631                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14632                       || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14633                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14634                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14635                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14636                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14637                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14638                           && ELF32_R_TYPE (irel->r_info) <=
14639                           R_NDS32_SDA12S2_SP_RELA)
14640                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14641                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14642                     {
14643                       r_symndx = ELF32_R_SYM (irel->r_info);
14644                       if (r_symndx < symtab_hdr->sh_info)
14645                         {
14646                           /* Local symbol.  */
14647                           int shndx = isym[r_symndx].st_shndx;
14648
14649                           isec = elf_elfsections (abfd)[shndx]->bfd_section;
14650                           if (ex9_insn->sec == isec
14651                               && ex9_insn->irel->r_addend == irel->r_addend
14652                               && ex9_insn->irel->r_info == irel->r_info)
14653                             {
14654                               do_replace = 1;
14655                               save_irel = 1;
14656                             }
14657                         }
14658                       else
14659                         {
14660                           /* External symbol.  */
14661                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14662                           if (ex9_insn->m_list)
14663                             {
14664                               h_list = ex9_insn->m_list->h_list;
14665                               while (h_list)
14666                                 {
14667                                   if (h == h_list->h
14668                                       && (ex9_insn->m_list->irel->r_addend ==
14669                                           irel->r_addend))
14670                                     {
14671                                       do_replace = 1;
14672                                       save_irel = 1;
14673                                       break;
14674                                     }
14675                                   h_list = h_list->next;
14676                                 }
14677                             }
14678                         }
14679                     }
14680                   else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14681                     {
14682                       r_symndx = ELF32_R_SYM (irel->r_info);
14683                       if (r_symndx < symtab_hdr->sh_info)
14684                         {
14685                           /* Local symbols.  Compare its base symbol and offset.  */
14686                           int shndx = isym[r_symndx].st_shndx;
14687
14688                           isec = elf_elfsections (abfd)[shndx]->bfd_section;
14689                           if (ex9_insn->sec == isec
14690                               && ex9_insn->irel->r_addend == irel->r_addend
14691                               && ex9_insn->irel->r_info == irel->r_info)
14692                             {
14693                               do_replace = 1;
14694                               save_irel = 1;
14695                             }
14696                         }
14697                       else
14698                         {
14699                           /* External symbol.  */
14700                           struct elf_link_hash_entry_mul_list *m_list;
14701
14702                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14703                           m_list = ex9_insn->m_list;
14704
14705                           while (m_list)
14706                             {
14707                               h_list = m_list->h_list;
14708
14709                               while (h_list)
14710                                 {
14711                                   if (h == h_list->h
14712                                       && (m_list->irel->r_addend
14713                                           == irel->r_addend))
14714                                     {
14715                                       do_replace = 1;
14716                                       save_irel = 1;
14717                                       if (ex9_insn->next
14718                                           && ex9_insn->m_list
14719                                           && ex9_insn->m_list == ex9_insn->next->m_list)
14720                                         {
14721                                           /* sethi multiple entry must be fixed */
14722                                           nds32_elf_ex9_insert_fix (sec, irel,
14723                                                                     h, ex9_insn->order);
14724                                         }
14725                                       break;
14726                                     }
14727                                   h_list = h_list->next;
14728                                 }
14729                               m_list = m_list->next;
14730                             }
14731                         }
14732                     }
14733                 }
14734
14735               /* Import table: Check the symbol hash table and the
14736                  jump target.  Only R_NDS32_25_PCREL_RELA now.  */
14737               else if (ex9_insn->times == -1
14738                        && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14739                 {
14740                   nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14741                   if (insn_with_reg == it_insn_with_reg)
14742                     {
14743                       char code[10];
14744                       bfd_vma relocation;
14745
14746                       r_symndx = ELF32_R_SYM (irel->r_info);
14747                       if (r_symndx >= symtab_hdr->sh_info)
14748                         {
14749                           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14750                           if ((h->root.type == bfd_link_hash_defined
14751                                || h->root.type == bfd_link_hash_defweak)
14752                               && h->root.u.def.section != NULL
14753                               && h->root.u.def.section->output_section != NULL
14754                               && h->root.u.def.section->gc_mark == 1
14755                               && bfd_is_abs_section (h->root.u.def.section)
14756                               && h->root.u.def.value > sec->size)
14757                             {
14758                               relocation = h->root.u.def.value +
14759                                 h->root.u.def.section->output_section->vma +
14760                                 h->root.u.def.section->output_offset;
14761                               relocation += irel->r_addend;
14762                               insn = insn_with_reg
14763                                 | ((relocation >> 1) & 0xffffff);
14764                               snprintf (code, sizeof (code), "%08x", insn);
14765                               if (strcmp (code, ex9_insn->string) == 0)
14766                                 {
14767                                   do_replace = 1;
14768                                   save_irel = 1;
14769                                 }
14770                             }
14771                         }
14772                     }
14773                 }
14774               else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14775                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14776                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14777                 {
14778                   /* These relocations do not have to relocate contens, so it can
14779                      be regard as instruction without relocation.  */
14780                   if (insn == it_insn && ex9_insn->irel == NULL)
14781                     do_replace = 1;
14782                 }
14783             }
14784           else
14785             {
14786               /* Instruction without relocation, we only
14787                  have to compare their byte code.  */
14788               if (insn == it_insn && ex9_insn->irel == NULL)
14789                 do_replace = 1;
14790             }
14791
14792           /* Insntruction match so replacing the code here.  */
14793           if (do_replace == 1)
14794             {
14795               /* There are two formats of ex9 instruction.  */
14796               if (ex9_insn->order < 32)
14797                 insn_ex9 = INSN_EX9_IT_2;
14798               else
14799                 insn_ex9 = INSN_EX9_IT_1;
14800               insn16 = insn_ex9 | ex9_insn->order;
14801
14802               /* Insert ex9 instruction.  */
14803               nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14804                                        &relax_blank_list, pre_irel_ptr,
14805                                        &irel_list);
14806               pre_off = off;
14807               pre_insn16 = insn16;
14808
14809               if (save_irel)
14810                 {
14811                   /* For instuction with relocation do relax.  */
14812                   irel_ptr = (struct elf_nds32_irel_entry *)
14813                     bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14814                   irel_ptr->irel = irel;
14815                   irel_ptr->next = NULL;
14816                   pre_irel_ptr = irel_ptr;
14817                 }
14818               else
14819                 pre_irel_ptr = NULL;
14820               break;
14821             }
14822           ex9_insn = ex9_insn->next;
14823         }
14824       off += 4;
14825     }
14826
14827   /* Insert ex9 instruction.  */
14828   nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14829                            &relax_blank_list, pre_irel_ptr,
14830                            &irel_list);
14831
14832   /* Delete the redundant code.  */
14833   if (relax_blank_list)
14834     {
14835       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14836       relax_blank_list = NULL;
14837     }
14838
14839   /* Clear the relocation that is replaced by ex9.  */
14840   while (irel_list)
14841     {
14842       struct elf_nds32_irel_entry *irel_ptr;
14843
14844       irel_ptr = irel_list;
14845       irel_list = irel_ptr->next;
14846       irel_ptr->irel->r_info =
14847         ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14848       free (irel_ptr);
14849     }
14850   return TRUE;
14851 }
14852
14853 /* Initialize ex9 hash table.  */
14854
14855 int
14856 nds32_elf_ex9_init (void)
14857 {
14858   if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14859                               sizeof (struct elf_nds32_code_hash_entry),
14860                               1023))
14861     {
14862       (*_bfd_error_handler) (_("Linker: cannot init ex9 hash table error \n"));
14863       return FALSE;
14864     }
14865   return TRUE;
14866 }
14867
14868 /* Predict how many bytes will be relaxed with ex9 and ifc.  */
14869
14870 static void
14871 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14872 {
14873   struct elf_nds32_insn_times_entry *ex9_insn;
14874   struct elf_nds32_insn_times_entry *temp;
14875   int target_optimize;
14876   struct elf_nds32_link_hash_table *table;
14877
14878   if (ex9_insn_head == NULL)
14879     return;
14880
14881   table = nds32_elf_hash_table (info);
14882   target_optimize  = table->target_optimize;
14883   ex9_insn = ex9_insn_head;
14884   while (ex9_insn)
14885     {
14886       ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14887       temp = ex9_insn;
14888       ex9_insn = ex9_insn->next;
14889       free (temp);
14890     }
14891   ex9_insn_head = NULL;
14892
14893   if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14894     {
14895       /* Examine ifc reduce size.  */
14896       struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14897       struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14898       int size = 0;
14899
14900       while (ifc_ent)
14901         {
14902           if (ifc_ent->enable == 0)
14903             {
14904               /* Not ifc yet.  */
14905               irel_ptr = ifc_ent->irel_head;
14906               while (irel_ptr)
14907                 {
14908                   size += 2;
14909                   irel_ptr = irel_ptr->next;
14910                 }
14911             }
14912           size -= 2;
14913           ifc_ent = ifc_ent->next;
14914         }
14915       ex9_relax_size += size;
14916     }
14917 }
14918
14919 /* Finish ex9 table.  */
14920
14921 void
14922 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14923 {
14924   nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14925   nds32_elf_order_insn_times (link_info);
14926   nds32_elf_ex9_total_relax (link_info);
14927   /* Traverse the hash table and count its times.  */
14928   nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14929   nds32_elf_order_insn_times (link_info);
14930   nds32_elf_ex9_build_itable (link_info);
14931 }
14932
14933 /* Relocate the entries in ex9 table.  */
14934
14935 static bfd_vma
14936 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14937                           struct bfd_link_info *link_info)
14938 {
14939   Elf_Internal_Sym *isym = NULL;
14940   bfd_vma relocation = -1;
14941   struct elf_link_hash_entry *h;
14942
14943   if (ptr->m_list != NULL)
14944     {
14945       /* Global symbol.  */
14946       h = ptr->m_list->h_list->h;
14947       if ((h->root.type == bfd_link_hash_defined
14948            || h->root.type == bfd_link_hash_defweak)
14949           && h->root.u.def.section != NULL
14950           && h->root.u.def.section->output_section != NULL)
14951         {
14952
14953           relocation = h->root.u.def.value +
14954             h->root.u.def.section->output_section->vma +
14955             h->root.u.def.section->output_offset;
14956           relocation += ptr->m_list->irel->r_addend;
14957         }
14958       else
14959         relocation = 0;
14960     }
14961   else if (ptr->sec !=NULL)
14962     {
14963       /* Local symbol.  */
14964       Elf_Internal_Sym sym;
14965       asection *sec = NULL;
14966       asection isec;
14967       asection *isec_ptr = &isec;
14968       Elf_Internal_Rela irel_backup = *(ptr->irel);
14969       asection *sec_backup = ptr->sec;
14970       bfd *abfd = ptr->sec->owner;
14971
14972       if (!nds32_get_local_syms (abfd, sec, &isym))
14973         return FALSE;
14974       isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14975
14976       sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14977       if (sec != NULL)
14978         *isec_ptr = *sec;
14979       sym = *isym;
14980
14981       /* The purpose is same as elf_link_input_bfd.  */
14982       if (isec_ptr != NULL
14983           && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14984           && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14985         {
14986           sym.st_value =
14987             _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14988                                         elf_section_data (isec_ptr)->sec_info,
14989                                         isym->st_value);
14990         }
14991       relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14992                                             &ptr->sec, ptr->irel);
14993       if (ptr->irel != NULL)
14994         relocation += ptr->irel->r_addend;
14995
14996       /* Restore origin value since there may be some insntructions that
14997          could not be replaced with ex9.it.  */
14998       *(ptr->irel) = irel_backup;
14999       ptr->sec = sec_backup;
15000     }
15001
15002   return relocation;
15003 }
15004
15005 /* Import ex9 table and build list.  */
15006
15007 void
15008 nds32_elf_ex9_import_table (struct bfd_link_info *info)
15009 {
15010   int num = 0;
15011   bfd_byte *contents;
15012   unsigned long insn;
15013   FILE *ex9_import_file;
15014   int update_ex9_table;
15015   struct elf_nds32_link_hash_table *table;
15016
15017   table = nds32_elf_hash_table (info);
15018   ex9_import_file = table->ex9_import_file;
15019   rewind (table->ex9_import_file);
15020
15021   contents = bfd_malloc (sizeof (bfd_byte) * 4);
15022
15023   /* Read instructions from the input file and build the list.  */
15024   while (!feof (ex9_import_file))
15025     {
15026       char *code;
15027       struct elf_nds32_insn_times_entry *ptr;
15028       size_t nread;
15029
15030       nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
15031       /* Ignore the final byte 0x0a.  */
15032       if (nread < 1)
15033         break;
15034       insn = bfd_getb32 (contents);
15035       code = bfd_malloc (sizeof (char) * 9);
15036       snprintf (code, 9, "%08lx", insn);
15037       ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
15038       ptr->string = code;
15039       ptr->order = num;
15040       ptr->times = -1;
15041       ptr->sec = NULL;
15042       ptr->m_list = NULL;
15043       ptr->rel_backup.r_offset = 0;
15044       ptr->rel_backup.r_info = 0;
15045       ptr->rel_backup.r_addend = 0;
15046       ptr->irel = NULL;
15047       ptr->next = NULL;
15048       nds32_elf_ex9_insert_entry (ptr);
15049       num++;
15050     }
15051
15052   update_ex9_table = table->update_ex9_table;
15053   if (update_ex9_table == 1)
15054     {
15055       /* It has to consider of sethi need to use multiple page
15056          but it not be done yet.  */
15057       nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
15058       nds32_elf_order_insn_times (info);
15059     }
15060 }
15061
15062 /* Export ex9 table.  */
15063
15064 static void
15065 nds32_elf_ex9_export (struct bfd_link_info *info,
15066                       bfd_byte *contents, int size)
15067 {
15068   FILE *ex9_export_file;
15069   struct elf_nds32_link_hash_table *table;
15070
15071   table = nds32_elf_hash_table (info);
15072   ex9_export_file = table->ex9_export_file;
15073   fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
15074   fclose (ex9_export_file);
15075 }
15076
15077 /* Adjust relocations of J and JAL in ex9.itable.
15078    Export ex9 table.  */
15079
15080 static void
15081 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
15082 {
15083   asection *table_sec = NULL;
15084   struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
15085   struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
15086   bfd *it_abfd;
15087   uint32_t insn, insn_with_reg, source_insn;
15088   bfd_byte *contents = NULL, *source_contents = NULL;
15089   int size = 0;
15090   bfd_vma gp;
15091   int shift, update_ex9_table, offset = 0;
15092   reloc_howto_type *howto = NULL;
15093   Elf_Internal_Rela rel_backup;
15094   unsigned short insn_ex9;
15095   struct elf_nds32_link_hash_table *table;
15096   FILE *ex9_export_file;
15097   static bfd_boolean done = FALSE;
15098
15099   if (done)
15100     return;
15101
15102   done = TRUE;
15103
15104   table = nds32_elf_hash_table (link_info);
15105   if (table)
15106     table->relax_status |= NDS32_RELAX_EX9_DONE;
15107
15108
15109   update_ex9_table = table->update_ex9_table;
15110   /* Generated ex9.itable exactly.  */
15111   if (update_ex9_table == 0)
15112     {
15113       for (it_abfd = link_info->input_bfds; it_abfd != NULL;
15114            it_abfd = it_abfd->link.next)
15115         {
15116           table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
15117           if (table_sec != NULL)
15118             break;
15119         }
15120
15121       if (table_sec != NULL)
15122         {
15123           bfd *output_bfd;
15124
15125           output_bfd = table_sec->output_section->owner;
15126           nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15127           if (table_sec->size == 0)
15128             return;
15129
15130           if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
15131             return;
15132         }
15133     }
15134   else
15135     {
15136       /* Set gp.  */
15137       bfd *output_bfd;
15138
15139       output_bfd = link_info->input_bfds->sections->output_section->owner;
15140       nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15141       contents = bfd_malloc (sizeof (bfd_byte) * 2048);
15142     }
15143
15144   /* Relocate instruction.  */
15145   while (ex9_insn)
15146     {
15147       bfd_vma relocation, min_relocation = 0xffffffff;
15148
15149       insn = strtol (ex9_insn->string, NULL, 16);
15150       insn_with_reg = 0;
15151       if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
15152         {
15153           if (ex9_insn->m_list)
15154             rel_backup = ex9_insn->m_list->rel_backup;
15155           else
15156             rel_backup = ex9_insn->rel_backup;
15157
15158           nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
15159           howto =
15160             bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
15161                                                    (rel_backup.r_info));
15162           shift = howto->rightshift;
15163           if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
15164               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
15165               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
15166               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
15167               || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
15168             {
15169               relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15170               insn =
15171                 insn_with_reg | ((relocation >> shift) &
15172                                  nds32_elf_irel_mask (&rel_backup));
15173               bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15174             }
15175           else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
15176                     && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
15177                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
15178                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
15179                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
15180                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
15181                    || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
15182                        && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
15183             {
15184               relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15185               insn =
15186                 insn_with_reg | (((relocation - gp) >> shift) &
15187                                  nds32_elf_irel_mask (&rel_backup));
15188               bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15189             }
15190           else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
15191             {
15192               /* Sethi may be multiple entry for one insn.  */
15193               if (ex9_insn->next && ex9_insn->m_list
15194                   && ex9_insn->m_list == ex9_insn->next->m_list)
15195                 {
15196                   struct elf_link_hash_entry_mul_list *m_list;
15197                   struct elf_nds32_ex9_refix *fix_ptr;
15198                   struct elf_link_hash_entry *h;
15199
15200                   temp_ptr = ex9_insn;
15201                   temp_ptr2 = ex9_insn;
15202                   m_list = ex9_insn->m_list;
15203                   while (m_list)
15204                     {
15205                       h = m_list->h_list->h;
15206                       relocation = h->root.u.def.value +
15207                         h->root.u.def.section->output_section->vma +
15208                         h->root.u.def.section->output_offset;
15209                       relocation += m_list->irel->r_addend;
15210
15211                       if (relocation < min_relocation)
15212                         min_relocation = relocation;
15213                       m_list = m_list->next;
15214                     }
15215                   relocation = min_relocation;
15216
15217                   /* Put insntruction into ex9 table.  */
15218                   insn = insn_with_reg
15219                     | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15220                   bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15221                   relocation = relocation + 0x1000;     /* hi20 */
15222
15223                   while (ex9_insn->next && ex9_insn->m_list
15224                          && ex9_insn->m_list == ex9_insn->next->m_list)
15225                     {
15226                       /* Multiple sethi.  */
15227                       ex9_insn = ex9_insn->next;
15228                       size += 4;
15229                       insn =
15230                         insn_with_reg | ((relocation >> shift) &
15231                                          nds32_elf_irel_mask (&rel_backup));
15232                       bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15233                       relocation = relocation + 0x1000; /* hi20 */
15234                     }
15235
15236                   fix_ptr = ex9_refix_head;
15237                   while (fix_ptr)
15238                     {
15239                       /* Fix ex9 insn.  */
15240                       /* temp_ptr2 points to the head of multiple sethi.  */
15241                       temp_ptr = temp_ptr2;
15242                       while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
15243                         {
15244                           fix_ptr = fix_ptr->next;
15245                         }
15246                       if (fix_ptr->order != temp_ptr->order)
15247                         break;
15248
15249                       /* Set source insn.  */
15250                       relocation =
15251                         fix_ptr->h->root.u.def.value +
15252                         fix_ptr->h->root.u.def.section->output_section->vma +
15253                         fix_ptr->h->root.u.def.section->output_offset;
15254                       relocation += fix_ptr->irel->r_addend;
15255                       /* sethi imm is imm20s.  */
15256                       source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15257
15258                       while (temp_ptr)
15259                         {
15260                           /* Match entry and source code.  */
15261                           insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15262                           if (insn == source_insn)
15263                             {
15264                               /* Fix the ex9 insn.  */
15265                               if (temp_ptr->order != fix_ptr->order)
15266                                 {
15267                                   if (!nds32_get_section_contents
15268                                          (fix_ptr->sec->owner, fix_ptr->sec,
15269                                           &source_contents, TRUE))
15270                                     (*_bfd_error_handler)
15271                                       (_("Linker: error cannot fixed ex9 relocation \n"));
15272                                   if (temp_ptr->order < 32)
15273                                     insn_ex9 = INSN_EX9_IT_2;
15274                                   else
15275                                     insn_ex9 = INSN_EX9_IT_1;
15276                                   insn_ex9 = insn_ex9 | temp_ptr->order;
15277                                   bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15278                                 }
15279                                 break;
15280                             }
15281                           else
15282                             {
15283                               if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15284                                 (*_bfd_error_handler)
15285                                   (_("Linker: error cannot fixed ex9 relocation \n"));
15286                               else
15287                                 temp_ptr = temp_ptr->next;
15288                             }
15289                         }
15290                       fix_ptr = fix_ptr->next;
15291                     }
15292                 }
15293               else
15294                 {
15295                   relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15296                   insn = insn_with_reg
15297                          | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15298                   bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15299                 }
15300             }
15301         }
15302       else
15303         {
15304           /* Insn without relocation does not have to be fixed
15305              if need to update export table.  */
15306           if (update_ex9_table == 1)
15307             bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15308         }
15309       ex9_insn = ex9_insn->next;
15310       size += 4;
15311     }
15312
15313   ex9_export_file = table->ex9_export_file;
15314   if (ex9_export_file != NULL)
15315     nds32_elf_ex9_export (link_info, contents, table_sec->size);
15316   else if (update_ex9_table == 1)
15317     {
15318       table->ex9_export_file = table->ex9_import_file;
15319       rewind (table->ex9_export_file);
15320       nds32_elf_ex9_export (link_info, contents, size);
15321     }
15322 }
15323
15324 /* Generate ex9 hash table.  */
15325
15326 static bfd_boolean
15327 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15328                                 struct bfd_link_info *link_info)
15329 {
15330   Elf_Internal_Rela *internal_relocs;
15331   Elf_Internal_Rela *irelend;
15332   Elf_Internal_Rela *irel;
15333   Elf_Internal_Rela *jrel;
15334   Elf_Internal_Rela rel_backup;
15335   Elf_Internal_Shdr *symtab_hdr;
15336   Elf_Internal_Sym *isym = NULL;
15337   asection *isec;
15338   struct elf_link_hash_entry **sym_hashes;
15339   bfd_byte *contents = NULL;
15340   bfd_vma off = 0;
15341   unsigned long r_symndx;
15342   uint32_t insn, insn_with_reg;
15343   struct elf_link_hash_entry *h;
15344   int data_flag, shift, align;
15345   bfd_vma relocation;
15346   /* Suppress ex9 if `.no_relax ex9' or inner loop.  */
15347   reloc_howto_type *howto = NULL;
15348
15349   sym_hashes = elf_sym_hashes (abfd);
15350   /* Load section instructions, relocations, and symbol table.  */
15351   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
15352     return FALSE;
15353
15354   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15355                                                TRUE /* keep_memory */);
15356   irelend = internal_relocs + sec->reloc_count;
15357   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15358   if (!nds32_get_local_syms (abfd, sec, &isym))
15359     return FALSE;
15360
15361   /* Check the object if enable ex9.  */
15362   irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15363                                  R_NDS32_RELAX_ENTRY);
15364
15365   /* Check this section trigger ex9 relaxation.  */
15366   if (irel == NULL
15367       || irel >= irelend
15368       || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15369       || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15370           && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15371     return TRUE;
15372
15373   irel = internal_relocs;
15374
15375   /* Push each insn into hash table.  */
15376   while (off < sec->size)
15377     {
15378       char code[10];
15379       struct elf_nds32_code_hash_entry *entry;
15380
15381       while (irel != NULL && irel < irelend && irel->r_offset < off)
15382         irel++;
15383
15384       data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15385                                                   NULL, sec, &off, contents);
15386       if (data_flag & DATA_EXIST)
15387         {
15388           /* We save the move offset in the highest byte.  */
15389           off += (data_flag >> 24);
15390           continue;
15391         }
15392
15393       if (*(contents + off) & 0x80)
15394         {
15395           off += 2;
15396         }
15397       else
15398         {
15399           h = NULL;
15400           isec = NULL;
15401           jrel = NULL;
15402           rel_backup.r_info = 0;
15403           rel_backup.r_offset = 0;
15404           rel_backup.r_addend = 0;
15405           /* Load the instruction and its opcode with register for comparing.  */
15406           insn = bfd_getb32 (contents + off);
15407           insn_with_reg = 0;
15408           if (irel != NULL && irel < irelend && irel->r_offset == off)
15409             {
15410               nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15411               howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15412               shift = howto->rightshift;
15413               align = (1 << shift) - 1;
15414               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15415                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15416                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15417                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15418                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15419                   || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15420                   ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15421                      && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15422                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15423                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15424                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15425                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15426                   || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15427                       && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15428                 {
15429                   r_symndx = ELF32_R_SYM (irel->r_info);
15430                   jrel = irel;
15431                   rel_backup = *irel;
15432                   if (r_symndx < symtab_hdr->sh_info)
15433                     {
15434                       /* Local symbol.  */
15435                       int shndx = isym[r_symndx].st_shndx;
15436
15437                       bfd_vma st_value = (isym + r_symndx)->st_value;
15438                       isec = elf_elfsections (abfd)[shndx]->bfd_section;
15439                       relocation = (isec->output_section->vma + isec->output_offset
15440                                     + st_value + irel->r_addend);
15441                     }
15442                   else
15443                     {
15444                       /* External symbol.  */
15445                       bfd_boolean warned ATTRIBUTE_UNUSED;
15446                       bfd_boolean ignored ATTRIBUTE_UNUSED;
15447                       bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15448                       asection *sym_sec;
15449
15450                       /* Maybe there is a better way to get h and relocation */
15451                       RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15452                                                r_symndx, symtab_hdr, sym_hashes,
15453                                                h, sym_sec, relocation,
15454                                                unresolved_reloc, warned, ignored);
15455                       relocation += irel->r_addend;
15456                       if ((h->root.type != bfd_link_hash_defined
15457                            && h->root.type != bfd_link_hash_defweak)
15458                           || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15459                         {
15460                           off += 4;
15461                           continue;
15462                         }
15463                     }
15464
15465                   /* Check for gp relative instruction alignment.  */
15466                   if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15467                        && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15468                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15469                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15470                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15471                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15472                       || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15473                           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15474                     {
15475                       bfd_vma gp;
15476                       bfd *output_bfd = sec->output_section->owner;
15477                       bfd_reloc_status_type r;
15478
15479                       /* If the symbol is in the abs section, the out_bfd will be null.
15480                          This happens when the relocation has a symbol@GOTOFF.  */
15481                       r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15482                       if (r != bfd_reloc_ok)
15483                         {
15484                           off += 4;
15485                           continue;
15486                         }
15487
15488                       relocation -= gp;
15489
15490                       /* Make sure alignment is correct.  */
15491                       if (relocation & align)
15492                         {
15493                           /* Incorrect alignment.  */
15494                           (*_bfd_error_handler)
15495                             (_("%s: warning: unaligned small data access. "
15496                                "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
15497                              bfd_get_filename (abfd), irel->r_offset,
15498                              irel->r_info, irel->r_addend, relocation, align);
15499                           off += 4;
15500                           continue;
15501                         }
15502                     }
15503
15504                   insn = insn_with_reg
15505                     | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15506                 }
15507               else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15508                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15509                        || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15510                 {
15511                   /* These relocations do not have to relocate contens, so it can
15512                      be regard as instruction without relocation.  */
15513                 }
15514               else
15515                 {
15516                   off += 4;
15517                   continue;
15518                 }
15519             }
15520
15521           snprintf (code, sizeof (code), "%08x", insn);
15522           /* Copy "code".  */
15523           entry = (struct elf_nds32_code_hash_entry*)
15524             bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15525           if (entry == NULL)
15526             {
15527               (*_bfd_error_handler)
15528                 (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
15529               return FALSE;
15530             }
15531           if (h)
15532             {
15533               if (h->root.type == bfd_link_hash_undefined)
15534                 return TRUE;
15535               /* Global symbol.  */
15536               /* In order to do sethi with different symbol but same value.  */
15537               if (entry->m_list == NULL)
15538                 {
15539                   struct elf_link_hash_entry_mul_list *m_list_new;
15540                   struct elf_link_hash_entry_list *h_list_new;
15541
15542                   m_list_new = (struct elf_link_hash_entry_mul_list *)
15543                     bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15544                   h_list_new = (struct elf_link_hash_entry_list *)
15545                     bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15546                   entry->m_list = m_list_new;
15547                   m_list_new->h_list = h_list_new;
15548                   m_list_new->rel_backup = rel_backup;
15549                   m_list_new->times = 1;
15550                   m_list_new->irel = jrel;
15551                   m_list_new->next = NULL;
15552                   h_list_new->h = h;
15553                   h_list_new->next = NULL;
15554                 }
15555               else
15556                 {
15557                   struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15558                   struct elf_link_hash_entry_list *h_list;
15559
15560                   while (m_list)
15561                     {
15562                       /* Build the different symbols that point to the same address.  */
15563                       h_list = m_list->h_list;
15564                       if (h_list->h->root.u.def.value == h->root.u.def.value
15565                           && h_list->h->root.u.def.section->output_section->vma
15566                              == h->root.u.def.section->output_section->vma
15567                           && h_list->h->root.u.def.section->output_offset
15568                              == h->root.u.def.section->output_offset
15569                           && m_list->rel_backup.r_addend == rel_backup.r_addend)
15570                         {
15571                           m_list->times++;
15572                           m_list->irel = jrel;
15573                           while (h_list->h != h && h_list->next)
15574                             h_list = h_list->next;
15575                           if (h_list->h != h)
15576                             {
15577                               struct elf_link_hash_entry_list *h_list_new;
15578
15579                               h_list_new = (struct elf_link_hash_entry_list *)
15580                                 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15581                               h_list->next = h_list_new;
15582                               h_list_new->h = h;
15583                               h_list_new->next = NULL;
15584                             }
15585                           break;
15586                         }
15587                       /* The sethi case may have different address but the
15588                          hi20 is the same.  */
15589                       else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15590                                && m_list->next == NULL)
15591                         {
15592                           struct elf_link_hash_entry_mul_list *m_list_new;
15593                           struct elf_link_hash_entry_list *h_list_new;
15594
15595                           m_list_new = (struct elf_link_hash_entry_mul_list *)
15596                             bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15597                           h_list_new = (struct elf_link_hash_entry_list *)
15598                             bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15599                           m_list->next = m_list_new;
15600                           m_list_new->h_list = h_list_new;
15601                           m_list_new->rel_backup = rel_backup;
15602                           m_list_new->times = 1;
15603                           m_list_new->irel = jrel;
15604                           m_list_new->next = NULL;
15605                           h_list_new->h = h;
15606                           h_list_new->next = NULL;
15607                           break;
15608                         }
15609                       m_list = m_list->next;
15610                     }
15611                   if (!m_list)
15612                     {
15613                       off += 4;
15614                       continue;
15615                     }
15616                 }
15617             }
15618           else
15619             {
15620               /* Local symbol and insn without relocation*/
15621               entry->times++;
15622               entry->rel_backup = rel_backup;
15623             }
15624
15625           /* Use in sethi insn with constant and global symbol in same format.  */
15626           if (!jrel)
15627             entry->const_insn = 1;
15628           else
15629             entry->irel = jrel;
15630           entry->sec = isec;
15631           off += 4;
15632         }
15633     }
15634   return TRUE;
15635 }
15636
15637 /* Set the _ITB_BASE, and point it to ex9 table.  */
15638
15639 bfd_boolean
15640 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15641 {
15642   bfd *abfd;
15643   asection *sec;
15644   bfd *output_bfd = NULL;
15645   struct bfd_link_hash_entry *bh = NULL;
15646
15647   if (is_ITB_BASE_set == 1)
15648     return TRUE;
15649
15650   is_ITB_BASE_set = 1;
15651
15652   bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15653
15654   if (bh && (bh->type == bfd_link_hash_defined
15655              || bh->type == bfd_link_hash_defweak))
15656     return TRUE;
15657
15658   for (abfd = link_info->input_bfds; abfd != NULL;
15659        abfd = abfd->link.next)
15660     {
15661       sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15662       if (sec != NULL)
15663         {
15664           output_bfd = sec->output_section->owner;
15665           break;
15666         }
15667     }
15668   if (output_bfd == NULL)
15669     {
15670       output_bfd = link_info->output_bfd;
15671       if (output_bfd->sections == NULL)
15672         return TRUE;
15673       else
15674         sec = bfd_abs_section_ptr;
15675     }
15676   bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15677                              FALSE, FALSE, TRUE);
15678   return (_bfd_generic_link_add_one_symbol
15679           (link_info, output_bfd, "_ITB_BASE_",
15680            BSF_GLOBAL | BSF_WEAK, sec, 0,
15681            (const char *) NULL, FALSE, get_elf_backend_data
15682            (output_bfd)->collect, &bh));
15683 } /* End EX9.IT  */
15684 \f
15685
15686 #define ELF_ARCH                                bfd_arch_nds32
15687 #define ELF_MACHINE_CODE                        EM_NDS32
15688 #define ELF_MAXPAGESIZE                         0x1000
15689 #define ELF_TARGET_ID                           NDS32_ELF_DATA
15690
15691 #define TARGET_BIG_SYM                          nds32_elf32_be_vec
15692 #define TARGET_BIG_NAME                         "elf32-nds32be"
15693 #define TARGET_LITTLE_SYM                       nds32_elf32_le_vec
15694 #define TARGET_LITTLE_NAME                      "elf32-nds32le"
15695
15696 #define elf_info_to_howto                       nds32_info_to_howto
15697 #define elf_info_to_howto_rel                   nds32_info_to_howto_rel
15698
15699 #define bfd_elf32_bfd_link_hash_table_create    nds32_elf_link_hash_table_create
15700 #define bfd_elf32_bfd_merge_private_bfd_data    nds32_elf_merge_private_bfd_data
15701 #define bfd_elf32_bfd_print_private_bfd_data    nds32_elf_print_private_bfd_data
15702 #define bfd_elf32_bfd_relax_section             nds32_elf_relax_section
15703 #define bfd_elf32_bfd_set_private_flags         nds32_elf_set_private_flags
15704
15705 #define bfd_elf32_mkobject                      nds32_elf_mkobject
15706 #define elf_backend_action_discarded            nds32_elf_action_discarded
15707 #define elf_backend_add_symbol_hook             nds32_elf_add_symbol_hook
15708 #define elf_backend_check_relocs                nds32_elf_check_relocs
15709 #define elf_backend_adjust_dynamic_symbol       nds32_elf_adjust_dynamic_symbol
15710 #define elf_backend_create_dynamic_sections     nds32_elf_create_dynamic_sections
15711 #define elf_backend_finish_dynamic_sections     nds32_elf_finish_dynamic_sections
15712 #define elf_backend_finish_dynamic_symbol       nds32_elf_finish_dynamic_symbol
15713 #define elf_backend_size_dynamic_sections       nds32_elf_size_dynamic_sections
15714 #define elf_backend_relocate_section            nds32_elf_relocate_section
15715 #define elf_backend_gc_mark_hook                nds32_elf_gc_mark_hook
15716 #define elf_backend_gc_sweep_hook               nds32_elf_gc_sweep_hook
15717 #define elf_backend_grok_prstatus               nds32_elf_grok_prstatus
15718 #define elf_backend_grok_psinfo                 nds32_elf_grok_psinfo
15719 #define elf_backend_reloc_type_class            nds32_elf_reloc_type_class
15720 #define elf_backend_copy_indirect_symbol        nds32_elf_copy_indirect_symbol
15721 #define elf_backend_link_output_symbol_hook     nds32_elf_output_symbol_hook
15722 #define elf_backend_output_arch_syms            nds32_elf_output_arch_syms
15723 #define elf_backend_object_p                    nds32_elf_object_p
15724 #define elf_backend_final_write_processing      nds32_elf_final_write_processing
15725 #define elf_backend_special_sections            nds32_elf_special_sections
15726 #define bfd_elf32_bfd_get_relocated_section_contents \
15727                                 nds32_elf_get_relocated_section_contents
15728
15729 #define elf_backend_can_gc_sections             1
15730 #define elf_backend_can_refcount                1
15731 #define elf_backend_want_got_plt                1
15732 #define elf_backend_plt_readonly                1
15733 #define elf_backend_want_plt_sym                0
15734 #define elf_backend_got_header_size             12
15735 #define elf_backend_may_use_rel_p               1
15736 #define elf_backend_default_use_rela_p          1
15737 #define elf_backend_may_use_rela_p              1
15738
15739 #include "elf32-target.h"
15740
15741 #undef ELF_MAXPAGESIZE
15742 #define ELF_MAXPAGESIZE                         0x2000
15743
15744 #undef TARGET_BIG_SYM
15745 #define TARGET_BIG_SYM                          nds32_elf32_linux_be_vec
15746 #undef TARGET_BIG_NAME
15747 #define TARGET_BIG_NAME                         "elf32-nds32be-linux"
15748 #undef TARGET_LITTLE_SYM
15749 #define TARGET_LITTLE_SYM                       nds32_elf32_linux_le_vec
15750 #undef TARGET_LITTLE_NAME
15751 #define TARGET_LITTLE_NAME                      "elf32-nds32le-linux"
15752 #undef elf32_bed
15753 #define elf32_bed                               elf32_nds32_lin_bed
15754
15755 #include "elf32-target.h"