projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove i386_elf_emit_arch_note
[deliverable/binutils-gdb.git] / bfd / elf32-xtensa.c
CommitLineData
e0001a05 1/* Xtensa-specific support for 32-bit ELF.
b90efa5b 2 Copyright (C) 2003-2015 Free Software Foundation, Inc.
e0001a05
NC		 3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
cd123cb7 8 published by the Free Software Foundation; either version 3 of the
e0001a05
NC		 9 License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
3e110533 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
53e09e0a 19 02110-1301, USA. */
e0001a05 20
e0001a05 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
e0001a05 23
e0001a05 24#include <stdarg.h>
e0001a05
NC		 25#include <strings.h>
26
27#include "bfdlink.h"
28#include "libbfd.h"
29#include "elf-bfd.h"
30#include "elf/xtensa.h"
4c2af04f 31#include "splay-tree.h"
e0001a05
NC		 32#include "xtensa-isa.h"
33#include "xtensa-config.h"
34
43cd72b9
BW		 35#define XTENSA_NO_NOP_REMOVAL 0
36
e0001a05
NC		 37/* Local helper functions. */
38
f0e6fdb2 39static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
2db662be 40static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
e0001a05 41static bfd_reloc_status_type bfd_elf_xtensa_reloc
7fa3d080 42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43cd72b9 43static bfd_boolean do_fix_for_relocatable_link
7fa3d080 44 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
e0001a05 45static void do_fix_for_final_link
7fa3d080 46 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
e0001a05
NC		 47
48/* Local functions to handle Xtensa configurability. */
49
7fa3d080
BW		 50static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
51static bfd_boolean is_direct_call_opcode (xtensa_opcode);
52static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
53static xtensa_opcode get_const16_opcode (void);
54static xtensa_opcode get_l32r_opcode (void);
55static bfd_vma l32r_offset (bfd_vma, bfd_vma);
56static int get_relocation_opnd (xtensa_opcode, int);
57static int get_relocation_slot (int);
e0001a05 58static xtensa_opcode get_relocation_opcode
7fa3d080 59 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
e0001a05 60static bfd_boolean is_l32r_relocation
7fa3d080
BW		 61 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
62static bfd_boolean is_alt_relocation (int);
63static bfd_boolean is_operand_relocation (int);
43cd72b9 64static bfd_size_type insn_decode_len
7fa3d080 65 (bfd_byte *, bfd_size_type, bfd_size_type);
43cd72b9 66static xtensa_opcode insn_decode_opcode
7fa3d080 67 (bfd_byte *, bfd_size_type, bfd_size_type, int);
43cd72b9 68static bfd_boolean check_branch_target_aligned
7fa3d080 69 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
43cd72b9 70static bfd_boolean check_loop_aligned
7fa3d080
BW		 71 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
72static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
43cd72b9 73static bfd_size_type get_asm_simplify_size
7fa3d080 74 (bfd_byte *, bfd_size_type, bfd_size_type);
e0001a05
NC		 75
76/* Functions for link-time code simplifications. */
77
43cd72b9 78static bfd_reloc_status_type elf_xtensa_do_asm_simplify
7fa3d080 79 (bfd_byte *, bfd_vma, bfd_vma, char **);
e0001a05 80static bfd_reloc_status_type contract_asm_expansion
7fa3d080
BW		 81 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
82static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
83static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
e0001a05
NC		 84
85/* Access to internal relocations, section contents and symbols. */
86
87static Elf_Internal_Rela *retrieve_internal_relocs
7fa3d080
BW		 88 (bfd *, asection *, bfd_boolean);
89static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
90static void release_internal_relocs (asection *, Elf_Internal_Rela *);
91static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
92static void pin_contents (asection *, bfd_byte *);
93static void release_contents (asection *, bfd_byte *);
94static Elf_Internal_Sym *retrieve_local_syms (bfd *);
e0001a05
NC		 95
96/* Miscellaneous utility functions. */
97
f0e6fdb2
BW		 98static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
99static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
7fa3d080 100static asection *get_elf_r_symndx_section (bfd *, unsigned long);
e0001a05 101static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
7fa3d080
BW		 102 (bfd *, unsigned long);
103static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
104static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
105static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
106static bfd_boolean xtensa_is_property_section (asection *);
1d25768e 107static bfd_boolean xtensa_is_insntable_section (asection *);
7fa3d080 108static bfd_boolean xtensa_is_littable_section (asection *);
1d25768e 109static bfd_boolean xtensa_is_proptable_section (asection *);
7fa3d080
BW		 110static int internal_reloc_compare (const void *, const void *);
111static int internal_reloc_matches (const void *, const void *);
51c8ebc1
BW		 112static asection *xtensa_get_property_section (asection *, const char *);
113extern asection *xtensa_make_property_section (asection *, const char *);
7fa3d080 114static flagword xtensa_get_property_predef_flags (asection *);
e0001a05
NC		 115
116/* Other functions called directly by the linker. */
117
118typedef void (*deps_callback_t)
7fa3d080 119 (asection *, bfd_vma, asection *, bfd_vma, void *);
e0001a05 120extern bfd_boolean xtensa_callback_required_dependence
7fa3d080 121 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
e0001a05
NC		 122
123
43cd72b9
BW		 124/* Globally visible flag for choosing size optimization of NOP removal
125 instead of branch-target-aware minimization for NOP removal.
126 When nonzero, narrow all instructions and remove all NOPs possible
127 around longcall expansions. */
7fa3d080 128
43cd72b9
BW		 129int elf32xtensa_size_opt;
130
131
132/* The "new_section_hook" is used to set up a per-section
133 "xtensa_relax_info" data structure with additional information used
134 during relaxation. */
e0001a05 135
7fa3d080 136typedef struct xtensa_relax_info_struct xtensa_relax_info;
e0001a05 137
43cd72b9 138
43cd72b9
BW		 139/* The GNU tools do not easily allow extending interfaces to pass around
140 the pointer to the Xtensa ISA information, so instead we add a global
141 variable here (in BFD) that can be used by any of the tools that need
142 this information. */
143
144xtensa_isa xtensa_default_isa;
145
146
e0001a05
NC		 147/* When this is true, relocations may have been modified to refer to
148 symbols from other input files. The per-section list of "fix"
149 records needs to be checked when resolving relocations. */
150
151static bfd_boolean relaxing_section = FALSE;
152
43cd72b9
BW		 153/* When this is true, during final links, literals that cannot be
154 coalesced and their relocations may be moved to other sections. */
155
156int elf32xtensa_no_literal_movement = 1;
157
b0dddeec
AM		 158/* Rename one of the generic section flags to better document how it
159 is used here. */
160/* Whether relocations have been processed. */
161#define reloc_done sec_flg0
e0001a05
NC		 162\f
163static reloc_howto_type elf_howto_table[] =
164{
6346d5ca 165 HOWTO (R_XTENSA_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
e0001a05 166 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
e5f131d1 167 FALSE, 0, 0, FALSE),
e0001a05
NC		 168 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
169 bfd_elf_xtensa_reloc, "R_XTENSA_32",
170 TRUE, 0xffffffff, 0xffffffff, FALSE),
e5f131d1 171
e0001a05
NC		 172 /* Replace a 32-bit value with a value from the runtime linker (only
173 used by linker-generated stub functions). The r_addend value is
174 special: 1 means to substitute a pointer to the runtime linker's
175 dynamic resolver function; 2 means to substitute the link map for
176 the shared object. */
177 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
e5f131d1
BW		 178 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
179
e0001a05
NC		 180 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
181 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
e5f131d1 182 FALSE, 0, 0xffffffff, FALSE),
e0001a05
NC		 183 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
184 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
e5f131d1 185 FALSE, 0, 0xffffffff, FALSE),
e0001a05
NC		 186 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
187 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
e5f131d1 188 FALSE, 0, 0xffffffff, FALSE),
e0001a05
NC		 189 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
190 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
e5f131d1
BW		 191 FALSE, 0, 0xffffffff, FALSE),
192
e0001a05 193 EMPTY_HOWTO (7),
e5f131d1
BW		 194
195 /* Old relocations for backward compatibility. */
e0001a05 196 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 197 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
e0001a05 198 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 199 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
e0001a05 200 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1
BW		 201 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
202
e0001a05
NC		 203 /* Assembly auto-expansion. */
204 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 205 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
e0001a05
NC		 206 /* Relax assembly auto-expansion. */
207 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1
BW		 208 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
209
e0001a05 210 EMPTY_HOWTO (13),
1bbb5f21
BW		 211
212 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
213 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
214 FALSE, 0, 0xffffffff, TRUE),
e5f131d1 215
e0001a05
NC		 216 /* GNU extension to record C++ vtable hierarchy. */
217 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
218 NULL, "R_XTENSA_GNU_VTINHERIT",
e5f131d1 219 FALSE, 0, 0, FALSE),
e0001a05
NC		 220 /* GNU extension to record C++ vtable member usage. */
221 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
222 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
e5f131d1 223 FALSE, 0, 0, FALSE),
43cd72b9
BW		 224
225 /* Relocations for supporting difference of symbols. */
1058c753 226 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
e5f131d1 227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
1058c753 228 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_signed,
e5f131d1 229 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
1058c753 230 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
e5f131d1 231 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
43cd72b9
BW		 232
233 /* General immediate operand relocations. */
234 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 235 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
43cd72b9 236 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 237 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
43cd72b9 238 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
43cd72b9 240 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
43cd72b9 242 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 243 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
43cd72b9 244 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
43cd72b9 246 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
43cd72b9 248 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 249 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
43cd72b9 250 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
43cd72b9 252 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
43cd72b9 254 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 255 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
43cd72b9 256 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
43cd72b9 258 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
43cd72b9 260 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 261 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
43cd72b9 262 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
43cd72b9
BW		 264
265 /* "Alternate" relocations. The meaning of these is opcode-specific. */
266 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 267 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
43cd72b9 268 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 269 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
43cd72b9 270 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
43cd72b9 272 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 273 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
43cd72b9 274 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
43cd72b9 276 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
43cd72b9 278 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 279 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
43cd72b9 280 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
43cd72b9 282 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 283 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
43cd72b9 284 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
43cd72b9 286 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 287 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
43cd72b9 288 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
43cd72b9 290 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
43cd72b9 292 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 293 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
43cd72b9 294 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
e5f131d1 295 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
28dbbc02
BW		 296
297 /* TLS relocations. */
298 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
299 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
300 FALSE, 0, 0xffffffff, FALSE),
301 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
302 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
303 FALSE, 0, 0xffffffff, FALSE),
304 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
305 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
306 FALSE, 0, 0xffffffff, FALSE),
307 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
308 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
309 FALSE, 0, 0xffffffff, FALSE),
310 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
311 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
312 FALSE, 0, 0, FALSE),
313 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
314 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
315 FALSE, 0, 0, FALSE),
316 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
317 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
318 FALSE, 0, 0, FALSE),
e0001a05
NC		 319};
320
43cd72b9 321#if DEBUG_GEN_RELOC
e0001a05
NC		 322#define TRACE(str) \
323 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
324#else
325#define TRACE(str)
326#endif
327
328static reloc_howto_type *
7fa3d080
BW		 329elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
330 bfd_reloc_code_real_type code)
e0001a05
NC		 331{
332 switch (code)
333 {
334 case BFD_RELOC_NONE:
335 TRACE ("BFD_RELOC_NONE");
336 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
337
338 case BFD_RELOC_32:
339 TRACE ("BFD_RELOC_32");
340 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
341
1bbb5f21
BW		 342 case BFD_RELOC_32_PCREL:
343 TRACE ("BFD_RELOC_32_PCREL");
344 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
345
43cd72b9
BW		 346 case BFD_RELOC_XTENSA_DIFF8:
347 TRACE ("BFD_RELOC_XTENSA_DIFF8");
348 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
349
350 case BFD_RELOC_XTENSA_DIFF16:
351 TRACE ("BFD_RELOC_XTENSA_DIFF16");
352 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
353
354 case BFD_RELOC_XTENSA_DIFF32:
355 TRACE ("BFD_RELOC_XTENSA_DIFF32");
356 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
357
e0001a05
NC		 358 case BFD_RELOC_XTENSA_RTLD:
359 TRACE ("BFD_RELOC_XTENSA_RTLD");
360 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
361
362 case BFD_RELOC_XTENSA_GLOB_DAT:
363 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
364 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
365
366 case BFD_RELOC_XTENSA_JMP_SLOT:
367 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
368 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
369
370 case BFD_RELOC_XTENSA_RELATIVE:
371 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
372 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
373
374 case BFD_RELOC_XTENSA_PLT:
375 TRACE ("BFD_RELOC_XTENSA_PLT");
376 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
377
378 case BFD_RELOC_XTENSA_OP0:
379 TRACE ("BFD_RELOC_XTENSA_OP0");
380 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
381
382 case BFD_RELOC_XTENSA_OP1:
383 TRACE ("BFD_RELOC_XTENSA_OP1");
384 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
385
386 case BFD_RELOC_XTENSA_OP2:
387 TRACE ("BFD_RELOC_XTENSA_OP2");
388 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
389
390 case BFD_RELOC_XTENSA_ASM_EXPAND:
391 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
392 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
393
394 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
395 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
396 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
397
398 case BFD_RELOC_VTABLE_INHERIT:
399 TRACE ("BFD_RELOC_VTABLE_INHERIT");
400 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
401
402 case BFD_RELOC_VTABLE_ENTRY:
403 TRACE ("BFD_RELOC_VTABLE_ENTRY");
404 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
405
28dbbc02
BW		 406 case BFD_RELOC_XTENSA_TLSDESC_FN:
407 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
408 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
409
410 case BFD_RELOC_XTENSA_TLSDESC_ARG:
411 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
412 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
413
414 case BFD_RELOC_XTENSA_TLS_DTPOFF:
415 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
416 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
417
418 case BFD_RELOC_XTENSA_TLS_TPOFF:
419 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
420 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
421
422 case BFD_RELOC_XTENSA_TLS_FUNC:
423 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
424 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
425
426 case BFD_RELOC_XTENSA_TLS_ARG:
427 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
428 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
429
430 case BFD_RELOC_XTENSA_TLS_CALL:
431 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
432 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
433
e0001a05 434 default:
43cd72b9
BW		 435 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
436 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
437 {
438 unsigned n = (R_XTENSA_SLOT0_OP +
439 (code - BFD_RELOC_XTENSA_SLOT0_OP));
440 return &elf_howto_table[n];
441 }
442
443 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
444 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
445 {
446 unsigned n = (R_XTENSA_SLOT0_ALT +
447 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
448 return &elf_howto_table[n];
449 }
450
e0001a05
NC		 451 break;
452 }
453
454 TRACE ("Unknown");
455 return NULL;
456}
457
157090f7
AM		 458static reloc_howto_type *
459elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
460 const char *r_name)
461{
462 unsigned int i;
463
464 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
465 if (elf_howto_table[i].name != NULL
466 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
467 return &elf_howto_table[i];
468
469 return NULL;
470}
471
e0001a05
NC		 472
473/* Given an ELF "rela" relocation, find the corresponding howto and record
474 it in the BFD internal arelent representation of the relocation. */
475
476static void
7fa3d080
BW		 477elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
478 arelent *cache_ptr,
479 Elf_Internal_Rela *dst)
e0001a05
NC		 480{
481 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
482
5860e3f8
NC		 483 if (r_type >= (unsigned int) R_XTENSA_max)
484 {
64d29018 485 _bfd_error_handler (_("%B: invalid XTENSA reloc number: %d"), abfd, r_type);
5860e3f8
NC		 486 r_type = 0;
487 }
e0001a05
NC		 488 cache_ptr->howto = &elf_howto_table[r_type];
489}
490
491\f
492/* Functions for the Xtensa ELF linker. */
493
494/* The name of the dynamic interpreter. This is put in the .interp
495 section. */
496
497#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
498
499/* The size in bytes of an entry in the procedure linkage table.
500 (This does _not_ include the space for the literals associated with
501 the PLT entry.) */
502
503#define PLT_ENTRY_SIZE 16
504
505/* For _really_ large PLTs, we may need to alternate between literals
506 and code to keep the literals within the 256K range of the L32R
507 instructions in the code. It's unlikely that anyone would ever need
508 such a big PLT, but an arbitrary limit on the PLT size would be bad.
509 Thus, we split the PLT into chunks. Since there's very little
510 overhead (2 extra literals) for each chunk, the chunk size is kept
511 small so that the code for handling multiple chunks get used and
512 tested regularly. With 254 entries, there are 1K of literals for
513 each chunk, and that seems like a nice round number. */
514
515#define PLT_ENTRIES_PER_CHUNK 254
516
517/* PLT entries are actually used as stub functions for lazy symbol
518 resolution. Once the symbol is resolved, the stub function is never
519 invoked. Note: the 32-byte frame size used here cannot be changed
520 without a corresponding change in the runtime linker. */
521
522static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
523{
524 0x6c, 0x10, 0x04, /* entry sp, 32 */
525 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
526 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
527 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
528 0x0a, 0x80, 0x00, /* jx a8 */
529 0 /* unused */
530};
531
532static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
533{
534 0x36, 0x41, 0x00, /* entry sp, 32 */
535 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
536 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
537 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
538 0xa0, 0x08, 0x00, /* jx a8 */
539 0 /* unused */
540};
541
28dbbc02
BW		 542/* The size of the thread control block. */
543#define TCB_SIZE 8
544
545struct elf_xtensa_link_hash_entry
546{
547 struct elf_link_hash_entry elf;
548
549 bfd_signed_vma tlsfunc_refcount;
550
551#define GOT_UNKNOWN 0
552#define GOT_NORMAL 1
553#define GOT_TLS_GD 2 /* global or local dynamic */
554#define GOT_TLS_IE 4 /* initial or local exec */
555#define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
556 unsigned char tls_type;
557};
558
559#define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
560
561struct elf_xtensa_obj_tdata
562{
563 struct elf_obj_tdata root;
564
565 /* tls_type for each local got entry. */
566 char *local_got_tls_type;
567
568 bfd_signed_vma *local_tlsfunc_refcounts;
569};
570
571#define elf_xtensa_tdata(abfd) \
572 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
573
574#define elf_xtensa_local_got_tls_type(abfd) \
575 (elf_xtensa_tdata (abfd)->local_got_tls_type)
576
577#define elf_xtensa_local_tlsfunc_refcounts(abfd) \
578 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
579
580#define is_xtensa_elf(bfd) \
581 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
582 && elf_tdata (bfd) != NULL \
4dfe6ac6 583 && elf_object_id (bfd) == XTENSA_ELF_DATA)
28dbbc02
BW		 584
585static bfd_boolean
586elf_xtensa_mkobject (bfd *abfd)
587{
588 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
4dfe6ac6 589 XTENSA_ELF_DATA);
28dbbc02
BW		 590}
591
f0e6fdb2
BW		 592/* Xtensa ELF linker hash table. */
593
594struct elf_xtensa_link_hash_table
595{
596 struct elf_link_hash_table elf;
597
598 /* Short-cuts to get to dynamic linker sections. */
599 asection *sgot;
600 asection *sgotplt;
601 asection *srelgot;
602 asection *splt;
603 asection *srelplt;
604 asection *sgotloc;
605 asection *spltlittbl;
606
607 /* Total count of PLT relocations seen during check_relocs.
608 The actual PLT code must be split into multiple sections and all
609 the sections have to be created before size_dynamic_sections,
610 where we figure out the exact number of PLT entries that will be
611 needed. It is OK if this count is an overestimate, e.g., some
612 relocations may be removed by GC. */
613 int plt_reloc_count;
28dbbc02
BW		 614
615 struct elf_xtensa_link_hash_entry *tlsbase;
f0e6fdb2
BW		 616};
617
618/* Get the Xtensa ELF linker hash table from a link_info structure. */
619
620#define elf_xtensa_hash_table(p) \
4dfe6ac6
NC		 621 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
622 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
f0e6fdb2 623
28dbbc02
BW		 624/* Create an entry in an Xtensa ELF linker hash table. */
625
626static struct bfd_hash_entry *
627elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
628 struct bfd_hash_table *table,
629 const char *string)
630{
631 /* Allocate the structure if it has not already been allocated by a
632 subclass. */
633 if (entry == NULL)
634 {
635 entry = bfd_hash_allocate (table,
636 sizeof (struct elf_xtensa_link_hash_entry));
637 if (entry == NULL)
638 return entry;
639 }
640
641 /* Call the allocation method of the superclass. */
642 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
643 if (entry != NULL)
644 {
645 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
646 eh->tlsfunc_refcount = 0;
647 eh->tls_type = GOT_UNKNOWN;
648 }
649
650 return entry;
651}
652
f0e6fdb2
BW		 653/* Create an Xtensa ELF linker hash table. */
654
655static struct bfd_link_hash_table *
656elf_xtensa_link_hash_table_create (bfd *abfd)
657{
28dbbc02 658 struct elf_link_hash_entry *tlsbase;
f0e6fdb2
BW		 659 struct elf_xtensa_link_hash_table *ret;
660 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
661
7bf52ea2 662 ret = bfd_zmalloc (amt);
f0e6fdb2
BW		 663 if (ret == NULL)
664 return NULL;
665
666 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
28dbbc02 667 elf_xtensa_link_hash_newfunc,
4dfe6ac6
NC		 668 sizeof (struct elf_xtensa_link_hash_entry),
669 XTENSA_ELF_DATA))
f0e6fdb2
BW		 670 {
671 free (ret);
672 return NULL;
673 }
674
28dbbc02
BW		 675 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
676 for it later. */
677 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
678 TRUE, FALSE, FALSE);
679 tlsbase->root.type = bfd_link_hash_new;
680 tlsbase->root.u.undef.abfd = NULL;
681 tlsbase->non_elf = 0;
682 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
683 ret->tlsbase->tls_type = GOT_UNKNOWN;
684
f0e6fdb2
BW		 685 return &ret->elf.root;
686}
571b5725 687
28dbbc02
BW		 688/* Copy the extra info we tack onto an elf_link_hash_entry. */
689
690static void
691elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
692 struct elf_link_hash_entry *dir,
693 struct elf_link_hash_entry *ind)
694{
695 struct elf_xtensa_link_hash_entry *edir, *eind;
696
697 edir = elf_xtensa_hash_entry (dir);
698 eind = elf_xtensa_hash_entry (ind);
699
700 if (ind->root.type == bfd_link_hash_indirect)
701 {
702 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
703 eind->tlsfunc_refcount = 0;
704
705 if (dir->got.refcount <= 0)
706 {
707 edir->tls_type = eind->tls_type;
708 eind->tls_type = GOT_UNKNOWN;
709 }
710 }
711
712 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
713}
714
571b5725 715static inline bfd_boolean
4608f3d9 716elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
7fa3d080 717 struct bfd_link_info *info)
571b5725
BW		 718{
719 /* Check if we should do dynamic things to this symbol. The
720 "ignore_protected" argument need not be set, because Xtensa code
721 does not require special handling of STV_PROTECTED to make function
722 pointer comparisons work properly. The PLT addresses are never
723 used for function pointers. */
724
725 return _bfd_elf_dynamic_symbol_p (h, info, 0);
726}
727
e0001a05
NC		 728\f
729static int
7fa3d080 730property_table_compare (const void *ap, const void *bp)
e0001a05
NC		 731{
732 const property_table_entry *a = (const property_table_entry *) ap;
733 const property_table_entry *b = (const property_table_entry *) bp;
734
43cd72b9
BW		 735 if (a->address == b->address)
736 {
43cd72b9
BW		 737 if (a->size != b->size)
738 return (a->size - b->size);
739
740 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
741 return ((b->flags & XTENSA_PROP_ALIGN)
742 - (a->flags & XTENSA_PROP_ALIGN));
743
744 if ((a->flags & XTENSA_PROP_ALIGN)
745 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
746 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
747 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
748 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
68ffbac6 749
43cd72b9
BW		 750 if ((a->flags & XTENSA_PROP_UNREACHABLE)
751 != (b->flags & XTENSA_PROP_UNREACHABLE))
752 return ((b->flags & XTENSA_PROP_UNREACHABLE)
753 - (a->flags & XTENSA_PROP_UNREACHABLE));
754
755 return (a->flags - b->flags);
756 }
757
758 return (a->address - b->address);
759}
760
761
762static int
7fa3d080 763property_table_matches (const void *ap, const void *bp)
43cd72b9
BW		 764{
765 const property_table_entry *a = (const property_table_entry *) ap;
766 const property_table_entry *b = (const property_table_entry *) bp;
767
768 /* Check if one entry overlaps with the other. */
e0001a05
NC		 769 if ((b->address >= a->address && b->address < (a->address + a->size))
770 || (a->address >= b->address && a->address < (b->address + b->size)))
771 return 0;
772
773 return (a->address - b->address);
774}
775
776
43cd72b9
BW		 777/* Get the literal table or property table entries for the given
778 section. Sets TABLE_P and returns the number of entries. On
779 error, returns a negative value. */
e0001a05 780
7fa3d080
BW		 781static int
782xtensa_read_table_entries (bfd *abfd,
783 asection *section,
784 property_table_entry **table_p,
785 const char *sec_name,
786 bfd_boolean output_addr)
e0001a05
NC		 787{
788 asection *table_section;
e0001a05
NC		 789 bfd_size_type table_size = 0;
790 bfd_byte *table_data;
791 property_table_entry *blocks;
e4115460 792 int blk, block_count;
e0001a05 793 bfd_size_type num_records;
bcc2cc8e
BW		 794 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
795 bfd_vma section_addr, off;
43cd72b9 796 flagword predef_flags;
bcc2cc8e 797 bfd_size_type table_entry_size, section_limit;
43cd72b9
BW		 798
799 if (!section
800 || !(section->flags & SEC_ALLOC)
801 || (section->flags & SEC_DEBUGGING))
802 {
803 *table_p = NULL;
804 return 0;
805 }
e0001a05 806
74869ac7 807 table_section = xtensa_get_property_section (section, sec_name);
43cd72b9 808 if (table_section)
eea6121a 809 table_size = table_section->size;
43cd72b9 810
68ffbac6 811 if (table_size == 0)
e0001a05
NC		 812 {
813 *table_p = NULL;
814 return 0;
815 }
816
43cd72b9
BW		 817 predef_flags = xtensa_get_property_predef_flags (table_section);
818 table_entry_size = 12;
819 if (predef_flags)
820 table_entry_size -= 4;
821
822 num_records = table_size / table_entry_size;
e0001a05
NC		 823 table_data = retrieve_contents (abfd, table_section, TRUE);
824 blocks = (property_table_entry *)
825 bfd_malloc (num_records * sizeof (property_table_entry));
826 block_count = 0;
43cd72b9
BW		 827
828 if (output_addr)
829 section_addr = section->output_section->vma + section->output_offset;
830 else
831 section_addr = section->vma;
3ba3bc8c 832
e0001a05 833 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
3ba3bc8c 834 if (internal_relocs && !table_section->reloc_done)
e0001a05 835 {
bcc2cc8e
BW		 836 qsort (internal_relocs, table_section->reloc_count,
837 sizeof (Elf_Internal_Rela), internal_reloc_compare);
838 irel = internal_relocs;
839 }
840 else
841 irel = NULL;
842
843 section_limit = bfd_get_section_limit (abfd, section);
844 rel_end = internal_relocs + table_section->reloc_count;
845
68ffbac6 846 for (off = 0; off < table_size; off += table_entry_size)
bcc2cc8e
BW		 847 {
848 bfd_vma address = bfd_get_32 (abfd, table_data + off);
849
850 /* Skip any relocations before the current offset. This should help
851 avoid confusion caused by unexpected relocations for the preceding
852 table entry. */
853 while (irel &&
854 (irel->r_offset < off
855 || (irel->r_offset == off
856 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
857 {
858 irel += 1;
859 if (irel >= rel_end)
860 irel = 0;
861 }
e0001a05 862
bcc2cc8e 863 if (irel && irel->r_offset == off)
e0001a05 864 {
bcc2cc8e
BW		 865 bfd_vma sym_off;
866 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
867 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
e0001a05 868
bcc2cc8e 869 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
e0001a05
NC		 870 continue;
871
bcc2cc8e
BW		 872 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
873 BFD_ASSERT (sym_off == 0);
874 address += (section_addr + sym_off + irel->r_addend);
e0001a05 875 }
bcc2cc8e 876 else
e0001a05 877 {
bcc2cc8e
BW		 878 if (address < section_addr
879 || address >= section_addr + section_limit)
880 continue;
e0001a05 881 }
bcc2cc8e
BW		 882
883 blocks[block_count].address = address;
884 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
885 if (predef_flags)
886 blocks[block_count].flags = predef_flags;
887 else
888 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
889 block_count++;
e0001a05
NC		 890 }
891
892 release_contents (table_section, table_data);
893 release_internal_relocs (table_section, internal_relocs);
894
43cd72b9 895 if (block_count > 0)
e0001a05
NC		 896 {
897 /* Now sort them into address order for easy reference. */
898 qsort (blocks, block_count, sizeof (property_table_entry),
899 property_table_compare);
e4115460
BW		 900
901 /* Check that the table contents are valid. Problems may occur,
902 for example, if an unrelocated object file is stripped. */
903 for (blk = 1; blk < block_count; blk++)
904 {
905 /* The only circumstance where two entries may legitimately
906 have the same address is when one of them is a zero-size
907 placeholder to mark a place where fill can be inserted.
908 The zero-size entry should come first. */
909 if (blocks[blk - 1].address == blocks[blk].address &&
910 blocks[blk - 1].size != 0)
911 {
912 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
913 abfd, section);
914 bfd_set_error (bfd_error_bad_value);
915 free (blocks);
916 return -1;
917 }
918 }
e0001a05 919 }
43cd72b9 920
e0001a05
NC		 921 *table_p = blocks;
922 return block_count;
923}
924
925
7fa3d080
BW		 926static property_table_entry *
927elf_xtensa_find_property_entry (property_table_entry *property_table,
928 int property_table_size,
929 bfd_vma addr)
e0001a05
NC		 930{
931 property_table_entry entry;
43cd72b9 932 property_table_entry *rv;
e0001a05 933
43cd72b9
BW		 934 if (property_table_size == 0)
935 return NULL;
e0001a05
NC		 936
937 entry.address = addr;
938 entry.size = 1;
43cd72b9 939 entry.flags = 0;
e0001a05 940
43cd72b9
BW		 941 rv = bsearch (&entry, property_table, property_table_size,
942 sizeof (property_table_entry), property_table_matches);
943 return rv;
944}
945
946
947static bfd_boolean
7fa3d080
BW		 948elf_xtensa_in_literal_pool (property_table_entry *lit_table,
949 int lit_table_size,
950 bfd_vma addr)
43cd72b9
BW		 951{
952 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
e0001a05
NC		 953 return TRUE;
954
955 return FALSE;
956}
957
958\f
959/* Look through the relocs for a section during the first phase, and
960 calculate needed space in the dynamic reloc sections. */
961
962static bfd_boolean
7fa3d080
BW		 963elf_xtensa_check_relocs (bfd *abfd,
964 struct bfd_link_info *info,
965 asection *sec,
966 const Elf_Internal_Rela *relocs)
e0001a05 967{
f0e6fdb2 968 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 969 Elf_Internal_Shdr *symtab_hdr;
970 struct elf_link_hash_entry **sym_hashes;
971 const Elf_Internal_Rela *rel;
972 const Elf_Internal_Rela *rel_end;
e0001a05 973
28dbbc02 974 if (info->relocatable || (sec->flags & SEC_ALLOC) == 0)
e0001a05
NC		 975 return TRUE;
976
28dbbc02
BW		 977 BFD_ASSERT (is_xtensa_elf (abfd));
978
f0e6fdb2 979 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 980 if (htab == NULL)
981 return FALSE;
982
e0001a05
NC		 983 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
984 sym_hashes = elf_sym_hashes (abfd);
985
e0001a05
NC		 986 rel_end = relocs + sec->reloc_count;
987 for (rel = relocs; rel < rel_end; rel++)
988 {
989 unsigned int r_type;
990 unsigned long r_symndx;
28dbbc02
BW		 991 struct elf_link_hash_entry *h = NULL;
992 struct elf_xtensa_link_hash_entry *eh;
993 int tls_type, old_tls_type;
994 bfd_boolean is_got = FALSE;
995 bfd_boolean is_plt = FALSE;
996 bfd_boolean is_tlsfunc = FALSE;
e0001a05
NC		 997
998 r_symndx = ELF32_R_SYM (rel->r_info);
999 r_type = ELF32_R_TYPE (rel->r_info);
1000
1001 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1002 {
d003868e
AM		 1003 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1004 abfd, r_symndx);
e0001a05
NC		 1005 return FALSE;
1006 }
1007
28dbbc02 1008 if (r_symndx >= symtab_hdr->sh_info)
e0001a05
NC		 1009 {
1010 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1011 while (h->root.type == bfd_link_hash_indirect
1012 || h->root.type == bfd_link_hash_warning)
1013 h = (struct elf_link_hash_entry *) h->root.u.i.link;
81fbe831
AM		 1014
1015 /* PR15323, ref flags aren't set for references in the same
1016 object. */
1017 h->root.non_ir_ref = 1;
e0001a05 1018 }
28dbbc02 1019 eh = elf_xtensa_hash_entry (h);
e0001a05
NC		 1020
1021 switch (r_type)
1022 {
28dbbc02
BW		 1023 case R_XTENSA_TLSDESC_FN:
1024 if (info->shared)
1025 {
1026 tls_type = GOT_TLS_GD;
1027 is_got = TRUE;
1028 is_tlsfunc = TRUE;
1029 }
1030 else
1031 tls_type = GOT_TLS_IE;
1032 break;
e0001a05 1033
28dbbc02
BW		 1034 case R_XTENSA_TLSDESC_ARG:
1035 if (info->shared)
e0001a05 1036 {
28dbbc02
BW		 1037 tls_type = GOT_TLS_GD;
1038 is_got = TRUE;
1039 }
1040 else
1041 {
1042 tls_type = GOT_TLS_IE;
1043 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1044 is_got = TRUE;
e0001a05
NC		 1045 }
1046 break;
1047
28dbbc02
BW		 1048 case R_XTENSA_TLS_DTPOFF:
1049 if (info->shared)
1050 tls_type = GOT_TLS_GD;
1051 else
1052 tls_type = GOT_TLS_IE;
1053 break;
1054
1055 case R_XTENSA_TLS_TPOFF:
1056 tls_type = GOT_TLS_IE;
1057 if (info->shared)
1058 info->flags |= DF_STATIC_TLS;
1059 if (info->shared || h)
1060 is_got = TRUE;
1061 break;
1062
1063 case R_XTENSA_32:
1064 tls_type = GOT_NORMAL;
1065 is_got = TRUE;
1066 break;
1067
e0001a05 1068 case R_XTENSA_PLT:
28dbbc02
BW		 1069 tls_type = GOT_NORMAL;
1070 is_plt = TRUE;
1071 break;
e0001a05 1072
28dbbc02
BW		 1073 case R_XTENSA_GNU_VTINHERIT:
1074 /* This relocation describes the C++ object vtable hierarchy.
1075 Reconstruct it for later use during GC. */
1076 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1077 return FALSE;
1078 continue;
1079
1080 case R_XTENSA_GNU_VTENTRY:
1081 /* This relocation describes which C++ vtable entries are actually
1082 used. Record for later use during GC. */
1083 BFD_ASSERT (h != NULL);
1084 if (h != NULL
1085 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1086 return FALSE;
1087 continue;
1088
1089 default:
1090 /* Nothing to do for any other relocations. */
1091 continue;
1092 }
1093
1094 if (h)
1095 {
1096 if (is_plt)
e0001a05 1097 {
b45329f9
BW		 1098 if (h->plt.refcount <= 0)
1099 {
1100 h->needs_plt = 1;
1101 h->plt.refcount = 1;
1102 }
1103 else
1104 h->plt.refcount += 1;
e0001a05
NC		 1105
1106 /* Keep track of the total PLT relocation count even if we
1107 don't yet know whether the dynamic sections will be
1108 created. */
f0e6fdb2 1109 htab->plt_reloc_count += 1;
e0001a05
NC		 1110
1111 if (elf_hash_table (info)->dynamic_sections_created)
1112 {
f0e6fdb2 1113 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
e0001a05
NC		 1114 return FALSE;
1115 }
1116 }
28dbbc02 1117 else if (is_got)
b45329f9
BW		 1118 {
1119 if (h->got.refcount <= 0)
1120 h->got.refcount = 1;
1121 else
1122 h->got.refcount += 1;
1123 }
28dbbc02
BW		 1124
1125 if (is_tlsfunc)
1126 eh->tlsfunc_refcount += 1;
e0001a05 1127
28dbbc02
BW		 1128 old_tls_type = eh->tls_type;
1129 }
1130 else
1131 {
1132 /* Allocate storage the first time. */
1133 if (elf_local_got_refcounts (abfd) == NULL)
e0001a05 1134 {
28dbbc02
BW		 1135 bfd_size_type size = symtab_hdr->sh_info;
1136 void *mem;
e0001a05 1137
28dbbc02
BW		 1138 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1139 if (mem == NULL)
1140 return FALSE;
1141 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
e0001a05 1142
28dbbc02
BW		 1143 mem = bfd_zalloc (abfd, size);
1144 if (mem == NULL)
1145 return FALSE;
1146 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1147
1148 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1149 if (mem == NULL)
1150 return FALSE;
1151 elf_xtensa_local_tlsfunc_refcounts (abfd)
1152 = (bfd_signed_vma *) mem;
e0001a05 1153 }
e0001a05 1154
28dbbc02
BW		 1155 /* This is a global offset table entry for a local symbol. */
1156 if (is_got || is_plt)
1157 elf_local_got_refcounts (abfd) [r_symndx] += 1;
e0001a05 1158
28dbbc02
BW		 1159 if (is_tlsfunc)
1160 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
e0001a05 1161
28dbbc02
BW		 1162 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1163 }
1164
1165 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1166 tls_type |= old_tls_type;
1167 /* If a TLS symbol is accessed using IE at least once,
1168 there is no point to use a dynamic model for it. */
1169 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1170 && ((old_tls_type & GOT_TLS_GD) == 0
1171 || (tls_type & GOT_TLS_IE) == 0))
1172 {
1173 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1174 tls_type = old_tls_type;
1175 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1176 tls_type |= old_tls_type;
1177 else
1178 {
1179 (*_bfd_error_handler)
1180 (_("%B: `%s' accessed both as normal and thread local symbol"),
1181 abfd,
1182 h ? h->root.root.string : "<local>");
1183 return FALSE;
1184 }
1185 }
1186
1187 if (old_tls_type != tls_type)
1188 {
1189 if (eh)
1190 eh->tls_type = tls_type;
1191 else
1192 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
e0001a05
NC		 1193 }
1194 }
1195
e0001a05
NC		 1196 return TRUE;
1197}
1198
1199
95147441
BW		 1200static void
1201elf_xtensa_make_sym_local (struct bfd_link_info *info,
1202 struct elf_link_hash_entry *h)
1203{
1204 if (info->shared)
1205 {
1206 if (h->plt.refcount > 0)
1207 {
1208 /* For shared objects, there's no need for PLT entries for local
1209 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1210 if (h->got.refcount < 0)
1211 h->got.refcount = 0;
1212 h->got.refcount += h->plt.refcount;
1213 h->plt.refcount = 0;
1214 }
1215 }
1216 else
1217 {
1218 /* Don't need any dynamic relocations at all. */
1219 h->plt.refcount = 0;
1220 h->got.refcount = 0;
1221 }
1222}
1223
1224
1225static void
1226elf_xtensa_hide_symbol (struct bfd_link_info *info,
1227 struct elf_link_hash_entry *h,
1228 bfd_boolean force_local)
1229{
1230 /* For a shared link, move the plt refcount to the got refcount to leave
1231 space for RELATIVE relocs. */
1232 elf_xtensa_make_sym_local (info, h);
1233
1234 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1235}
1236
1237
e0001a05
NC		 1238/* Return the section that should be marked against GC for a given
1239 relocation. */
1240
1241static asection *
7fa3d080 1242elf_xtensa_gc_mark_hook (asection *sec,
07adf181 1243 struct bfd_link_info *info,
7fa3d080
BW		 1244 Elf_Internal_Rela *rel,
1245 struct elf_link_hash_entry *h,
1246 Elf_Internal_Sym *sym)
e0001a05 1247{
e1e5c0b5
BW		 1248 /* Property sections are marked "KEEP" in the linker scripts, but they
1249 should not cause other sections to be marked. (This approach relies
1250 on elf_xtensa_discard_info to remove property table entries that
1251 describe discarded sections. Alternatively, it might be more
1252 efficient to avoid using "KEEP" in the linker scripts and instead use
1253 the gc_mark_extra_sections hook to mark only the property sections
1254 that describe marked sections. That alternative does not work well
1255 with the current property table sections, which do not correspond
1256 one-to-one with the sections they describe, but that should be fixed
1257 someday.) */
1258 if (xtensa_is_property_section (sec))
1259 return NULL;
1260
07adf181
AM		 1261 if (h != NULL)
1262 switch (ELF32_R_TYPE (rel->r_info))
1263 {
1264 case R_XTENSA_GNU_VTINHERIT:
1265 case R_XTENSA_GNU_VTENTRY:
1266 return NULL;
1267 }
1268
1269 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
e0001a05
NC		 1270}
1271
7fa3d080 1272
e0001a05
NC		 1273/* Update the GOT & PLT entry reference counts
1274 for the section being removed. */
1275
1276static bfd_boolean
7fa3d080 1277elf_xtensa_gc_sweep_hook (bfd *abfd,
28dbbc02 1278 struct bfd_link_info *info,
7fa3d080
BW		 1279 asection *sec,
1280 const Elf_Internal_Rela *relocs)
e0001a05
NC		 1281{
1282 Elf_Internal_Shdr *symtab_hdr;
1283 struct elf_link_hash_entry **sym_hashes;
e0001a05 1284 const Elf_Internal_Rela *rel, *relend;
28dbbc02
BW		 1285 struct elf_xtensa_link_hash_table *htab;
1286
1287 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1288 if (htab == NULL)
1289 return FALSE;
e0001a05 1290
7dda2462
TG		 1291 if (info->relocatable)
1292 return TRUE;
1293
e0001a05
NC		 1294 if ((sec->flags & SEC_ALLOC) == 0)
1295 return TRUE;
1296
1297 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1298 sym_hashes = elf_sym_hashes (abfd);
e0001a05
NC		 1299
1300 relend = relocs + sec->reloc_count;
1301 for (rel = relocs; rel < relend; rel++)
1302 {
1303 unsigned long r_symndx;
1304 unsigned int r_type;
1305 struct elf_link_hash_entry *h = NULL;
28dbbc02
BW		 1306 struct elf_xtensa_link_hash_entry *eh;
1307 bfd_boolean is_got = FALSE;
1308 bfd_boolean is_plt = FALSE;
1309 bfd_boolean is_tlsfunc = FALSE;
e0001a05
NC		 1310
1311 r_symndx = ELF32_R_SYM (rel->r_info);
1312 if (r_symndx >= symtab_hdr->sh_info)
3eb128b2
AM		 1313 {
1314 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1315 while (h->root.type == bfd_link_hash_indirect
1316 || h->root.type == bfd_link_hash_warning)
1317 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1318 }
28dbbc02 1319 eh = elf_xtensa_hash_entry (h);
e0001a05
NC		 1320
1321 r_type = ELF32_R_TYPE (rel->r_info);
1322 switch (r_type)
1323 {
28dbbc02
BW		 1324 case R_XTENSA_TLSDESC_FN:
1325 if (info->shared)
1326 {
1327 is_got = TRUE;
1328 is_tlsfunc = TRUE;
1329 }
e0001a05
NC		 1330 break;
1331
28dbbc02
BW		 1332 case R_XTENSA_TLSDESC_ARG:
1333 if (info->shared)
1334 is_got = TRUE;
1335 else
1336 {
1337 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1338 is_got = TRUE;
1339 }
e0001a05
NC		 1340 break;
1341
28dbbc02
BW		 1342 case R_XTENSA_TLS_TPOFF:
1343 if (info->shared || h)
1344 is_got = TRUE;
e0001a05
NC		 1345 break;
1346
28dbbc02
BW		 1347 case R_XTENSA_32:
1348 is_got = TRUE;
e0001a05 1349 break;
28dbbc02
BW		 1350
1351 case R_XTENSA_PLT:
1352 is_plt = TRUE;
1353 break;
1354
1355 default:
1356 continue;
1357 }
1358
1359 if (h)
1360 {
1361 if (is_plt)
1362 {
1363 if (h->plt.refcount > 0)
1364 h->plt.refcount--;
1365 }
1366 else if (is_got)
1367 {
1368 if (h->got.refcount > 0)
1369 h->got.refcount--;
1370 }
1371 if (is_tlsfunc)
1372 {
1373 if (eh->tlsfunc_refcount > 0)
1374 eh->tlsfunc_refcount--;
1375 }
1376 }
1377 else
1378 {
1379 if (is_got || is_plt)
1380 {
1381 bfd_signed_vma *got_refcount
1382 = &elf_local_got_refcounts (abfd) [r_symndx];
1383 if (*got_refcount > 0)
1384 *got_refcount -= 1;
1385 }
1386 if (is_tlsfunc)
1387 {
1388 bfd_signed_vma *tlsfunc_refcount
1389 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1390 if (*tlsfunc_refcount > 0)
1391 *tlsfunc_refcount -= 1;
1392 }
e0001a05
NC		 1393 }
1394 }
1395
1396 return TRUE;
1397}
1398
1399
1400/* Create all the dynamic sections. */
1401
1402static bfd_boolean
7fa3d080 1403elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
e0001a05 1404{
f0e6fdb2 1405 struct elf_xtensa_link_hash_table *htab;
e901de89 1406 flagword flags, noalloc_flags;
f0e6fdb2
BW		 1407
1408 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1409 if (htab == NULL)
1410 return FALSE;
e0001a05
NC		 1411
1412 /* First do all the standard stuff. */
1413 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1414 return FALSE;
3d4d4302
AM		 1415 htab->splt = bfd_get_linker_section (dynobj, ".plt");
1416 htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
1417 htab->sgot = bfd_get_linker_section (dynobj, ".got");
1418 htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1419 htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
e0001a05
NC		 1420
1421 /* Create any extra PLT sections in case check_relocs has already
1422 been called on all the non-dynamic input files. */
f0e6fdb2 1423 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
e0001a05
NC		 1424 return FALSE;
1425
e901de89
BW		 1426 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1427 | SEC_LINKER_CREATED | SEC_READONLY);
1428 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
e0001a05
NC		 1429
1430 /* Mark the ".got.plt" section READONLY. */
f0e6fdb2
BW		 1431 if (htab->sgotplt == NULL
1432 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
e0001a05
NC		 1433 return FALSE;
1434
e901de89 1435 /* Create ".got.loc" (literal tables for use by dynamic linker). */
3d4d4302
AM		 1436 htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
1437 flags);
f0e6fdb2
BW		 1438 if (htab->sgotloc == NULL
1439 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
e901de89
BW		 1440 return FALSE;
1441
e0001a05 1442 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
3d4d4302
AM		 1443 htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
1444 noalloc_flags);
f0e6fdb2
BW		 1445 if (htab->spltlittbl == NULL
1446 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
e0001a05
NC		 1447 return FALSE;
1448
1449 return TRUE;
1450}
1451
1452
1453static bfd_boolean
f0e6fdb2 1454add_extra_plt_sections (struct bfd_link_info *info, int count)
e0001a05 1455{
f0e6fdb2 1456 bfd *dynobj = elf_hash_table (info)->dynobj;
e0001a05
NC		 1457 int chunk;
1458
1459 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1460 ".got.plt" sections. */
1461 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1462 {
1463 char *sname;
1464 flagword flags;
1465 asection *s;
1466
1467 /* Stop when we find a section has already been created. */
f0e6fdb2 1468 if (elf_xtensa_get_plt_section (info, chunk))
e0001a05
NC		 1469 break;
1470
1471 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1472 | SEC_LINKER_CREATED | SEC_READONLY);
1473
1474 sname = (char *) bfd_malloc (10);
1475 sprintf (sname, ".plt.%u", chunk);
3d4d4302 1476 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);
e0001a05 1477 if (s == NULL
e0001a05
NC		 1478 || ! bfd_set_section_alignment (dynobj, s, 2))
1479 return FALSE;
1480
1481 sname = (char *) bfd_malloc (14);
1482 sprintf (sname, ".got.plt.%u", chunk);
3d4d4302 1483 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);
e0001a05 1484 if (s == NULL
e0001a05
NC		 1485 || ! bfd_set_section_alignment (dynobj, s, 2))
1486 return FALSE;
1487 }
1488
1489 return TRUE;
1490}
1491
1492
1493/* Adjust a symbol defined by a dynamic object and referenced by a
1494 regular object. The current definition is in some section of the
1495 dynamic object, but we're not including those sections. We have to
1496 change the definition to something the rest of the link can
1497 understand. */
1498
1499static bfd_boolean
7fa3d080
BW		 1500elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1501 struct elf_link_hash_entry *h)
e0001a05
NC		 1502{
1503 /* If this is a weak symbol, and there is a real definition, the
1504 processor independent code will have arranged for us to see the
1505 real definition first, and we can just use the same value. */
7fa3d080 1506 if (h->u.weakdef)
e0001a05 1507 {
f6e332e6
AM		 1508 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1509 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1510 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1511 h->root.u.def.value = h->u.weakdef->root.u.def.value;
e0001a05
NC		 1512 return TRUE;
1513 }
1514
1515 /* This is a reference to a symbol defined by a dynamic object. The
1516 reference must go through the GOT, so there's no need for COPY relocs,
1517 .dynbss, etc. */
1518
1519 return TRUE;
1520}
1521
1522
e0001a05 1523static bfd_boolean
f1ab2340 1524elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
e0001a05 1525{
f1ab2340
BW		 1526 struct bfd_link_info *info;
1527 struct elf_xtensa_link_hash_table *htab;
28dbbc02 1528 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
e0001a05 1529
f1ab2340
BW		 1530 if (h->root.type == bfd_link_hash_indirect)
1531 return TRUE;
e0001a05 1532
f1ab2340
BW		 1533 info = (struct bfd_link_info *) arg;
1534 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1535 if (htab == NULL)
1536 return FALSE;
e0001a05 1537
28dbbc02
BW		 1538 /* If we saw any use of an IE model for this symbol, we can then optimize
1539 away GOT entries for any TLSDESC_FN relocs. */
1540 if ((eh->tls_type & GOT_TLS_IE) != 0)
1541 {
1542 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1543 h->got.refcount -= eh->tlsfunc_refcount;
1544 }
e0001a05 1545
28dbbc02 1546 if (! elf_xtensa_dynamic_symbol_p (h, info))
95147441 1547 elf_xtensa_make_sym_local (info, h);
e0001a05 1548
f1ab2340
BW		 1549 if (h->plt.refcount > 0)
1550 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
e0001a05
NC		 1551
1552 if (h->got.refcount > 0)
f1ab2340 1553 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
e0001a05
NC		 1554
1555 return TRUE;
1556}
1557
1558
1559static void
f0e6fdb2 1560elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
e0001a05 1561{
f0e6fdb2 1562 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 1563 bfd *i;
1564
f0e6fdb2 1565 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1566 if (htab == NULL)
1567 return;
f0e6fdb2 1568
c72f2fb2 1569 for (i = info->input_bfds; i; i = i->link.next)
e0001a05
NC		 1570 {
1571 bfd_signed_vma *local_got_refcounts;
1572 bfd_size_type j, cnt;
1573 Elf_Internal_Shdr *symtab_hdr;
1574
1575 local_got_refcounts = elf_local_got_refcounts (i);
1576 if (!local_got_refcounts)
1577 continue;
1578
1579 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1580 cnt = symtab_hdr->sh_info;
1581
1582 for (j = 0; j < cnt; ++j)
1583 {
28dbbc02
BW		 1584 /* If we saw any use of an IE model for this symbol, we can
1585 then optimize away GOT entries for any TLSDESC_FN relocs. */
1586 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1587 {
1588 bfd_signed_vma *tlsfunc_refcount
1589 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1590 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1591 local_got_refcounts[j] -= *tlsfunc_refcount;
1592 }
1593
e0001a05 1594 if (local_got_refcounts[j] > 0)
f0e6fdb2
BW		 1595 htab->srelgot->size += (local_got_refcounts[j]
1596 * sizeof (Elf32_External_Rela));
e0001a05
NC		 1597 }
1598 }
1599}
1600
1601
1602/* Set the sizes of the dynamic sections. */
1603
1604static bfd_boolean
7fa3d080
BW		 1605elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1606 struct bfd_link_info *info)
e0001a05 1607{
f0e6fdb2 1608 struct elf_xtensa_link_hash_table *htab;
e901de89
BW		 1609 bfd *dynobj, *abfd;
1610 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
e0001a05
NC		 1611 bfd_boolean relplt, relgot;
1612 int plt_entries, plt_chunks, chunk;
1613
1614 plt_entries = 0;
1615 plt_chunks = 0;
e0001a05 1616
f0e6fdb2 1617 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1618 if (htab == NULL)
1619 return FALSE;
1620
e0001a05
NC		 1621 dynobj = elf_hash_table (info)->dynobj;
1622 if (dynobj == NULL)
1623 abort ();
f0e6fdb2
BW		 1624 srelgot = htab->srelgot;
1625 srelplt = htab->srelplt;
e0001a05
NC		 1626
1627 if (elf_hash_table (info)->dynamic_sections_created)
1628 {
f0e6fdb2
BW		 1629 BFD_ASSERT (htab->srelgot != NULL
1630 && htab->srelplt != NULL
1631 && htab->sgot != NULL
1632 && htab->spltlittbl != NULL
1633 && htab->sgotloc != NULL);
1634
e0001a05 1635 /* Set the contents of the .interp section to the interpreter. */
893c4fe2 1636 if (info->executable)
e0001a05 1637 {
3d4d4302 1638 s = bfd_get_linker_section (dynobj, ".interp");
e0001a05
NC		 1639 if (s == NULL)
1640 abort ();
eea6121a 1641 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
e0001a05
NC		 1642 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1643 }
1644
1645 /* Allocate room for one word in ".got". */
f0e6fdb2 1646 htab->sgot->size = 4;
e0001a05 1647
f1ab2340
BW		 1648 /* Allocate space in ".rela.got" for literals that reference global
1649 symbols and space in ".rela.plt" for literals that have PLT
1650 entries. */
e0001a05 1651 elf_link_hash_traverse (elf_hash_table (info),
f1ab2340 1652 elf_xtensa_allocate_dynrelocs,
7fa3d080 1653 (void *) info);
e0001a05 1654
e0001a05
NC		 1655 /* If we are generating a shared object, we also need space in
1656 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1657 reference local symbols. */
1658 if (info->shared)
f0e6fdb2 1659 elf_xtensa_allocate_local_got_size (info);
e0001a05 1660
e0001a05
NC		 1661 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1662 each PLT entry, we need the PLT code plus a 4-byte literal.
1663 For each chunk of ".plt", we also need two more 4-byte
1664 literals, two corresponding entries in ".rela.got", and an
1665 8-byte entry in ".xt.lit.plt". */
f0e6fdb2 1666 spltlittbl = htab->spltlittbl;
eea6121a 1667 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 1668 plt_chunks =
1669 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1670
1671 /* Iterate over all the PLT chunks, including any extra sections
1672 created earlier because the initial count of PLT relocations
1673 was an overestimate. */
1674 for (chunk = 0;
f0e6fdb2 1675 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
e0001a05
NC		 1676 chunk++)
1677 {
1678 int chunk_entries;
1679
f0e6fdb2
BW		 1680 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1681 BFD_ASSERT (sgotplt != NULL);
e0001a05
NC		 1682
1683 if (chunk < plt_chunks - 1)
1684 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1685 else if (chunk == plt_chunks - 1)
1686 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1687 else
1688 chunk_entries = 0;
1689
1690 if (chunk_entries != 0)
1691 {
eea6121a
AM		 1692 sgotplt->size = 4 * (chunk_entries + 2);
1693 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1694 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1695 spltlittbl->size += 8;
e0001a05
NC		 1696 }
1697 else
1698 {
eea6121a
AM		 1699 sgotplt->size = 0;
1700 splt->size = 0;
e0001a05
NC		 1701 }
1702 }
e901de89
BW		 1703
1704 /* Allocate space in ".got.loc" to match the total size of all the
1705 literal tables. */
f0e6fdb2 1706 sgotloc = htab->sgotloc;
eea6121a 1707 sgotloc->size = spltlittbl->size;
c72f2fb2 1708 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
e901de89
BW		 1709 {
1710 if (abfd->flags & DYNAMIC)
1711 continue;
1712 for (s = abfd->sections; s != NULL; s = s->next)
1713 {
dbaa2011 1714 if (! discarded_section (s)
b536dc1e
BW		 1715 && xtensa_is_littable_section (s)
1716 && s != spltlittbl)
eea6121a 1717 sgotloc->size += s->size;
e901de89
BW		 1718 }
1719 }
e0001a05
NC		 1720 }
1721
1722 /* Allocate memory for dynamic sections. */
1723 relplt = FALSE;
1724 relgot = FALSE;
1725 for (s = dynobj->sections; s != NULL; s = s->next)
1726 {
1727 const char *name;
e0001a05
NC		 1728
1729 if ((s->flags & SEC_LINKER_CREATED) == 0)
1730 continue;
1731
1732 /* It's OK to base decisions on the section name, because none
1733 of the dynobj section names depend upon the input files. */
1734 name = bfd_get_section_name (dynobj, s);
1735
0112cd26 1736 if (CONST_STRNEQ (name, ".rela"))
e0001a05 1737 {
c456f082 1738 if (s->size != 0)
e0001a05 1739 {
c456f082
AM		 1740 if (strcmp (name, ".rela.plt") == 0)
1741 relplt = TRUE;
1742 else if (strcmp (name, ".rela.got") == 0)
1743 relgot = TRUE;
1744
1745 /* We use the reloc_count field as a counter if we need
1746 to copy relocs into the output file. */
1747 s->reloc_count = 0;
e0001a05
NC		 1748 }
1749 }
0112cd26
NC		 1750 else if (! CONST_STRNEQ (name, ".plt.")
1751 && ! CONST_STRNEQ (name, ".got.plt.")
c456f082 1752 && strcmp (name, ".got") != 0
e0001a05
NC		 1753 && strcmp (name, ".plt") != 0
1754 && strcmp (name, ".got.plt") != 0
e901de89
BW		 1755 && strcmp (name, ".xt.lit.plt") != 0
1756 && strcmp (name, ".got.loc") != 0)
e0001a05
NC		 1757 {
1758 /* It's not one of our sections, so don't allocate space. */
1759 continue;
1760 }
1761
c456f082
AM		 1762 if (s->size == 0)
1763 {
1764 /* If we don't need this section, strip it from the output
1765 file. We must create the ".plt*" and ".got.plt*"
1766 sections in create_dynamic_sections and/or check_relocs
1767 based on a conservative estimate of the PLT relocation
1768 count, because the sections must be created before the
1769 linker maps input sections to output sections. The
1770 linker does that before size_dynamic_sections, where we
1771 compute the exact size of the PLT, so there may be more
1772 of these sections than are actually needed. */
1773 s->flags |= SEC_EXCLUDE;
1774 }
1775 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
e0001a05
NC		 1776 {
1777 /* Allocate memory for the section contents. */
eea6121a 1778 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c456f082 1779 if (s->contents == NULL)
e0001a05
NC		 1780 return FALSE;
1781 }
1782 }
1783
1784 if (elf_hash_table (info)->dynamic_sections_created)
1785 {
1786 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1787 known until finish_dynamic_sections, but we need to get the relocs
1788 in place before they are sorted. */
e0001a05
NC		 1789 for (chunk = 0; chunk < plt_chunks; chunk++)
1790 {
1791 Elf_Internal_Rela irela;
1792 bfd_byte *loc;
1793
1794 irela.r_offset = 0;
1795 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1796 irela.r_addend = 0;
1797
1798 loc = (srelgot->contents
1799 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1800 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1801 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1802 loc + sizeof (Elf32_External_Rela));
1803 srelgot->reloc_count += 2;
1804 }
1805
1806 /* Add some entries to the .dynamic section. We fill in the
1807 values later, in elf_xtensa_finish_dynamic_sections, but we
1808 must add the entries now so that we get the correct size for
1809 the .dynamic section. The DT_DEBUG entry is filled in by the
1810 dynamic linker and used by the debugger. */
1811#define add_dynamic_entry(TAG, VAL) \
5a580b3a 1812 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
e0001a05 1813
ba05963f 1814 if (info->executable)
e0001a05
NC		 1815 {
1816 if (!add_dynamic_entry (DT_DEBUG, 0))
1817 return FALSE;
1818 }
1819
1820 if (relplt)
1821 {
c243ad3b 1822 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
e0001a05
NC		 1823 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1824 || !add_dynamic_entry (DT_JMPREL, 0))
1825 return FALSE;
1826 }
1827
1828 if (relgot)
1829 {
1830 if (!add_dynamic_entry (DT_RELA, 0)
1831 || !add_dynamic_entry (DT_RELASZ, 0)
1832 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1833 return FALSE;
1834 }
1835
c243ad3b
BW		 1836 if (!add_dynamic_entry (DT_PLTGOT, 0)
1837 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
e0001a05
NC		 1838 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1839 return FALSE;
1840 }
1841#undef add_dynamic_entry
1842
1843 return TRUE;
1844}
1845
28dbbc02
BW		 1846static bfd_boolean
1847elf_xtensa_always_size_sections (bfd *output_bfd,
1848 struct bfd_link_info *info)
1849{
1850 struct elf_xtensa_link_hash_table *htab;
1851 asection *tls_sec;
1852
1853 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1854 if (htab == NULL)
1855 return FALSE;
1856
28dbbc02
BW		 1857 tls_sec = htab->elf.tls_sec;
1858
1859 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1860 {
1861 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1862 struct bfd_link_hash_entry *bh = &tlsbase->root;
1863 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1864
1865 tlsbase->type = STT_TLS;
1866 if (!(_bfd_generic_link_add_one_symbol
1867 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1868 tls_sec, 0, NULL, FALSE,
1869 bed->collect, &bh)))
1870 return FALSE;
1871 tlsbase->def_regular = 1;
1872 tlsbase->other = STV_HIDDEN;
1873 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1874 }
1875
1876 return TRUE;
1877}
1878
e0001a05 1879\f
28dbbc02
BW		 1880/* Return the base VMA address which should be subtracted from real addresses
1881 when resolving @dtpoff relocation.
1882 This is PT_TLS segment p_vaddr. */
1883
1884static bfd_vma
1885dtpoff_base (struct bfd_link_info *info)
1886{
1887 /* If tls_sec is NULL, we should have signalled an error already. */
1888 if (elf_hash_table (info)->tls_sec == NULL)
1889 return 0;
1890 return elf_hash_table (info)->tls_sec->vma;
1891}
1892
1893/* Return the relocation value for @tpoff relocation
1894 if STT_TLS virtual address is ADDRESS. */
1895
1896static bfd_vma
1897tpoff (struct bfd_link_info *info, bfd_vma address)
1898{
1899 struct elf_link_hash_table *htab = elf_hash_table (info);
1900 bfd_vma base;
1901
1902 /* If tls_sec is NULL, we should have signalled an error already. */
1903 if (htab->tls_sec == NULL)
1904 return 0;
1905 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1906 return address - htab->tls_sec->vma + base;
1907}
1908
e0001a05
NC		 1909/* Perform the specified relocation. The instruction at (contents + address)
1910 is modified to set one operand to represent the value in "relocation". The
1911 operand position is determined by the relocation type recorded in the
1912 howto. */
1913
1914#define CALL_SEGMENT_BITS (30)
7fa3d080 1915#define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
e0001a05
NC		 1916
1917static bfd_reloc_status_type
7fa3d080
BW		 1918elf_xtensa_do_reloc (reloc_howto_type *howto,
1919 bfd *abfd,
1920 asection *input_section,
1921 bfd_vma relocation,
1922 bfd_byte *contents,
1923 bfd_vma address,
1924 bfd_boolean is_weak_undef,
1925 char **error_message)
e0001a05 1926{
43cd72b9 1927 xtensa_format fmt;
e0001a05 1928 xtensa_opcode opcode;
e0001a05 1929 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 1930 static xtensa_insnbuf ibuff = NULL;
1931 static xtensa_insnbuf sbuff = NULL;
1bbb5f21 1932 bfd_vma self_address;
43cd72b9
BW		 1933 bfd_size_type input_size;
1934 int opnd, slot;
e0001a05
NC		 1935 uint32 newval;
1936
43cd72b9
BW		 1937 if (!ibuff)
1938 {
1939 ibuff = xtensa_insnbuf_alloc (isa);
1940 sbuff = xtensa_insnbuf_alloc (isa);
1941 }
1942
1943 input_size = bfd_get_section_limit (abfd, input_section);
1944
1bbb5f21
BW		 1945 /* Calculate the PC address for this instruction. */
1946 self_address = (input_section->output_section->vma
1947 + input_section->output_offset
1948 + address);
1949
e0001a05
NC		 1950 switch (howto->type)
1951 {
1952 case R_XTENSA_NONE:
43cd72b9
BW		 1953 case R_XTENSA_DIFF8:
1954 case R_XTENSA_DIFF16:
1955 case R_XTENSA_DIFF32:
28dbbc02
BW		 1956 case R_XTENSA_TLS_FUNC:
1957 case R_XTENSA_TLS_ARG:
1958 case R_XTENSA_TLS_CALL:
e0001a05
NC		 1959 return bfd_reloc_ok;
1960
1961 case R_XTENSA_ASM_EXPAND:
1962 if (!is_weak_undef)
1963 {
1964 /* Check for windowed CALL across a 1GB boundary. */
91d6fa6a
NC		 1965 opcode = get_expanded_call_opcode (contents + address,
1966 input_size - address, 0);
e0001a05
NC		 1967 if (is_windowed_call_opcode (opcode))
1968 {
43cd72b9 1969 if ((self_address >> CALL_SEGMENT_BITS)
68ffbac6 1970 != (relocation >> CALL_SEGMENT_BITS))
e0001a05
NC		 1971 {
1972 *error_message = "windowed longcall crosses 1GB boundary; "
1973 "return may fail";
1974 return bfd_reloc_dangerous;
1975 }
1976 }
1977 }
1978 return bfd_reloc_ok;
1979
1980 case R_XTENSA_ASM_SIMPLIFY:
43cd72b9 1981 {
e0001a05 1982 /* Convert the L32R/CALLX to CALL. */
43cd72b9
BW		 1983 bfd_reloc_status_type retval =
1984 elf_xtensa_do_asm_simplify (contents, address, input_size,
1985 error_message);
e0001a05 1986 if (retval != bfd_reloc_ok)
43cd72b9 1987 return bfd_reloc_dangerous;
e0001a05
NC		 1988
1989 /* The CALL needs to be relocated. Continue below for that part. */
1990 address += 3;
c46082c8 1991 self_address += 3;
43cd72b9 1992 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
e0001a05
NC		 1993 }
1994 break;
1995
1996 case R_XTENSA_32:
e0001a05
NC		 1997 {
1998 bfd_vma x;
1999 x = bfd_get_32 (abfd, contents + address);
2000 x = x + relocation;
2001 bfd_put_32 (abfd, x, contents + address);
2002 }
2003 return bfd_reloc_ok;
1bbb5f21
BW		 2004
2005 case R_XTENSA_32_PCREL:
2006 bfd_put_32 (abfd, relocation - self_address, contents + address);
2007 return bfd_reloc_ok;
28dbbc02
BW		 2008
2009 case R_XTENSA_PLT:
2010 case R_XTENSA_TLSDESC_FN:
2011 case R_XTENSA_TLSDESC_ARG:
2012 case R_XTENSA_TLS_DTPOFF:
2013 case R_XTENSA_TLS_TPOFF:
2014 bfd_put_32 (abfd, relocation, contents + address);
2015 return bfd_reloc_ok;
e0001a05
NC		 2016 }
2017
43cd72b9
BW		 2018 /* Only instruction slot-specific relocations handled below.... */
2019 slot = get_relocation_slot (howto->type);
2020 if (slot == XTENSA_UNDEFINED)
e0001a05 2021 {
43cd72b9 2022 *error_message = "unexpected relocation";
e0001a05
NC		 2023 return bfd_reloc_dangerous;
2024 }
2025
43cd72b9
BW		 2026 /* Read the instruction into a buffer and decode the opcode. */
2027 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2028 input_size - address);
2029 fmt = xtensa_format_decode (isa, ibuff);
2030 if (fmt == XTENSA_UNDEFINED)
e0001a05 2031 {
43cd72b9 2032 *error_message = "cannot decode instruction format";
e0001a05
NC		 2033 return bfd_reloc_dangerous;
2034 }
2035
43cd72b9 2036 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
e0001a05 2037
43cd72b9
BW		 2038 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2039 if (opcode == XTENSA_UNDEFINED)
e0001a05 2040 {
43cd72b9 2041 *error_message = "cannot decode instruction opcode";
e0001a05
NC		 2042 return bfd_reloc_dangerous;
2043 }
2044
43cd72b9
BW		 2045 /* Check for opcode-specific "alternate" relocations. */
2046 if (is_alt_relocation (howto->type))
2047 {
2048 if (opcode == get_l32r_opcode ())
2049 {
2050 /* Handle the special-case of non-PC-relative L32R instructions. */
2051 bfd *output_bfd = input_section->output_section->owner;
2052 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2053 if (!lit4_sec)
2054 {
2055 *error_message = "relocation references missing .lit4 section";
2056 return bfd_reloc_dangerous;
2057 }
2058 self_address = ((lit4_sec->vma & ~0xfff)
2059 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2060 newval = relocation;
2061 opnd = 1;
2062 }
2063 else if (opcode == get_const16_opcode ())
2064 {
2065 /* ALT used for high 16 bits. */
2066 newval = relocation >> 16;
2067 opnd = 1;
2068 }
2069 else
2070 {
2071 /* No other "alternate" relocations currently defined. */
2072 *error_message = "unexpected relocation";
2073 return bfd_reloc_dangerous;
2074 }
2075 }
2076 else /* Not an "alternate" relocation.... */
2077 {
2078 if (opcode == get_const16_opcode ())
2079 {
2080 newval = relocation & 0xffff;
2081 opnd = 1;
2082 }
2083 else
2084 {
2085 /* ...normal PC-relative relocation.... */
2086
2087 /* Determine which operand is being relocated. */
2088 opnd = get_relocation_opnd (opcode, howto->type);
2089 if (opnd == XTENSA_UNDEFINED)
2090 {
2091 *error_message = "unexpected relocation";
2092 return bfd_reloc_dangerous;
2093 }
2094
2095 if (!howto->pc_relative)
2096 {
2097 *error_message = "expected PC-relative relocation";
2098 return bfd_reloc_dangerous;
2099 }
e0001a05 2100
43cd72b9
BW		 2101 newval = relocation;
2102 }
2103 }
e0001a05 2104
43cd72b9
BW		 2105 /* Apply the relocation. */
2106 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2107 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2108 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2109 sbuff, newval))
e0001a05 2110 {
2db662be
BW		 2111 const char *opname = xtensa_opcode_name (isa, opcode);
2112 const char *msg;
2113
2114 msg = "cannot encode";
2115 if (is_direct_call_opcode (opcode))
2116 {
2117 if ((relocation & 0x3) != 0)
2118 msg = "misaligned call target";
2119 else
2120 msg = "call target out of range";
2121 }
2122 else if (opcode == get_l32r_opcode ())
2123 {
2124 if ((relocation & 0x3) != 0)
2125 msg = "misaligned literal target";
2126 else if (is_alt_relocation (howto->type))
2127 msg = "literal target out of range (too many literals)";
2128 else if (self_address > relocation)
2129 msg = "literal target out of range (try using text-section-literals)";
2130 else
2131 msg = "literal placed after use";
2132 }
2133
2134 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
e0001a05
NC		 2135 return bfd_reloc_dangerous;
2136 }
2137
43cd72b9 2138 /* Check for calls across 1GB boundaries. */
e0001a05
NC		 2139 if (is_direct_call_opcode (opcode)
2140 && is_windowed_call_opcode (opcode))
2141 {
43cd72b9 2142 if ((self_address >> CALL_SEGMENT_BITS)
68ffbac6 2143 != (relocation >> CALL_SEGMENT_BITS))
e0001a05 2144 {
43cd72b9
BW		 2145 *error_message =
2146 "windowed call crosses 1GB boundary; return may fail";
e0001a05
NC		 2147 return bfd_reloc_dangerous;
2148 }
2149 }
2150
43cd72b9
BW		 2151 /* Write the modified instruction back out of the buffer. */
2152 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2153 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2154 input_size - address);
e0001a05
NC		 2155 return bfd_reloc_ok;
2156}
2157
2158
2db662be 2159static char *
7fa3d080 2160vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
e0001a05
NC		 2161{
2162 /* To reduce the size of the memory leak,
2163 we only use a single message buffer. */
2164 static bfd_size_type alloc_size = 0;
2165 static char *message = NULL;
2166 bfd_size_type orig_len, len = 0;
2167 bfd_boolean is_append;
1651e569 2168 va_list ap;
e0001a05 2169
1651e569 2170 va_start (ap, arglen);
68ffbac6
L		 2171
2172 is_append = (origmsg == message);
e0001a05
NC		 2173
2174 orig_len = strlen (origmsg);
2175 len = orig_len + strlen (fmt) + arglen + 20;
2176 if (len > alloc_size)
2177 {
515ef31d 2178 message = (char *) bfd_realloc_or_free (message, len);
e0001a05
NC		 2179 alloc_size = len;
2180 }
515ef31d
NC		 2181 if (message != NULL)
2182 {
2183 if (!is_append)
2184 memcpy (message, origmsg, orig_len);
2185 vsprintf (message + orig_len, fmt, ap);
2186 }
1651e569 2187 va_end (ap);
e0001a05
NC		 2188 return message;
2189}
2190
2191
e0001a05
NC		 2192/* This function is registered as the "special_function" in the
2193 Xtensa howto for handling simplify operations.
2194 bfd_perform_relocation / bfd_install_relocation use it to
2195 perform (install) the specified relocation. Since this replaces the code
2196 in bfd_perform_relocation, it is basically an Xtensa-specific,
2197 stripped-down version of bfd_perform_relocation. */
2198
2199static bfd_reloc_status_type
7fa3d080
BW		 2200bfd_elf_xtensa_reloc (bfd *abfd,
2201 arelent *reloc_entry,
2202 asymbol *symbol,
2203 void *data,
2204 asection *input_section,
2205 bfd *output_bfd,
2206 char **error_message)
e0001a05
NC		 2207{
2208 bfd_vma relocation;
2209 bfd_reloc_status_type flag;
2210 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2211 bfd_vma output_base = 0;
2212 reloc_howto_type *howto = reloc_entry->howto;
2213 asection *reloc_target_output_section;
2214 bfd_boolean is_weak_undef;
2215
dd1a320b
BW		 2216 if (!xtensa_default_isa)
2217 xtensa_default_isa = xtensa_isa_init (0, 0);
2218
1049f94e 2219 /* ELF relocs are against symbols. If we are producing relocatable
e0001a05
NC		 2220 output, and the reloc is against an external symbol, the resulting
2221 reloc will also be against the same symbol. In such a case, we
2222 don't want to change anything about the way the reloc is handled,
2223 since it will all be done at final link time. This test is similar
2224 to what bfd_elf_generic_reloc does except that it lets relocs with
2225 howto->partial_inplace go through even if the addend is non-zero.
2226 (The real problem is that partial_inplace is set for XTENSA_32
2227 relocs to begin with, but that's a long story and there's little we
2228 can do about it now....) */
2229
7fa3d080 2230 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
e0001a05
NC		 2231 {
2232 reloc_entry->address += input_section->output_offset;
2233 return bfd_reloc_ok;
2234 }
2235
2236 /* Is the address of the relocation really within the section? */
07515404 2237 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
e0001a05
NC		 2238 return bfd_reloc_outofrange;
2239
4cc11e76 2240 /* Work out which section the relocation is targeted at and the
e0001a05
NC		 2241 initial relocation command value. */
2242
2243 /* Get symbol value. (Common symbols are special.) */
2244 if (bfd_is_com_section (symbol->section))
2245 relocation = 0;
2246 else
2247 relocation = symbol->value;
2248
2249 reloc_target_output_section = symbol->section->output_section;
2250
2251 /* Convert input-section-relative symbol value to absolute. */
2252 if ((output_bfd && !howto->partial_inplace)
2253 || reloc_target_output_section == NULL)
2254 output_base = 0;
2255 else
2256 output_base = reloc_target_output_section->vma;
2257
2258 relocation += output_base + symbol->section->output_offset;
2259
2260 /* Add in supplied addend. */
2261 relocation += reloc_entry->addend;
2262
2263 /* Here the variable relocation holds the final address of the
2264 symbol we are relocating against, plus any addend. */
2265 if (output_bfd)
2266 {
2267 if (!howto->partial_inplace)
2268 {
2269 /* This is a partial relocation, and we want to apply the relocation
2270 to the reloc entry rather than the raw data. Everything except
2271 relocations against section symbols has already been handled
2272 above. */
43cd72b9 2273
e0001a05
NC		 2274 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2275 reloc_entry->addend = relocation;
2276 reloc_entry->address += input_section->output_offset;
2277 return bfd_reloc_ok;
2278 }
2279 else
2280 {
2281 reloc_entry->address += input_section->output_offset;
2282 reloc_entry->addend = 0;
2283 }
2284 }
2285
2286 is_weak_undef = (bfd_is_und_section (symbol->section)
2287 && (symbol->flags & BSF_WEAK) != 0);
2288 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2289 (bfd_byte *) data, (bfd_vma) octets,
2290 is_weak_undef, error_message);
2291
2292 if (flag == bfd_reloc_dangerous)
2293 {
2294 /* Add the symbol name to the error message. */
2295 if (! *error_message)
2296 *error_message = "";
2297 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2298 strlen (symbol->name) + 17,
70961b9d
AM		 2299 symbol->name,
2300 (unsigned long) reloc_entry->addend);
e0001a05
NC		 2301 }
2302
2303 return flag;
2304}
2305
2306
2307/* Set up an entry in the procedure linkage table. */
2308
2309static bfd_vma
f0e6fdb2 2310elf_xtensa_create_plt_entry (struct bfd_link_info *info,
7fa3d080
BW		 2311 bfd *output_bfd,
2312 unsigned reloc_index)
e0001a05
NC		 2313{
2314 asection *splt, *sgotplt;
2315 bfd_vma plt_base, got_base;
2316 bfd_vma code_offset, lit_offset;
2317 int chunk;
2318
2319 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
f0e6fdb2
BW		 2320 splt = elf_xtensa_get_plt_section (info, chunk);
2321 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 2322 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2323
2324 plt_base = splt->output_section->vma + splt->output_offset;
2325 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2326
2327 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2328 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2329
2330 /* Fill in the literal entry. This is the offset of the dynamic
2331 relocation entry. */
2332 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2333 sgotplt->contents + lit_offset);
2334
2335 /* Fill in the entry in the procedure linkage table. */
2336 memcpy (splt->contents + code_offset,
2337 (bfd_big_endian (output_bfd)
2338 ? elf_xtensa_be_plt_entry
2339 : elf_xtensa_le_plt_entry),
2340 PLT_ENTRY_SIZE);
2341 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2342 plt_base + code_offset + 3),
2343 splt->contents + code_offset + 4);
2344 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2345 plt_base + code_offset + 6),
2346 splt->contents + code_offset + 7);
2347 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2348 plt_base + code_offset + 9),
2349 splt->contents + code_offset + 10);
2350
2351 return plt_base + code_offset;
2352}
2353
2354
28dbbc02
BW		 2355static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2356
2357static bfd_boolean
2358replace_tls_insn (Elf_Internal_Rela *rel,
2359 bfd *abfd,
2360 asection *input_section,
2361 bfd_byte *contents,
2362 bfd_boolean is_ld_model,
2363 char **error_message)
2364{
2365 static xtensa_insnbuf ibuff = NULL;
2366 static xtensa_insnbuf sbuff = NULL;
2367 xtensa_isa isa = xtensa_default_isa;
2368 xtensa_format fmt;
2369 xtensa_opcode old_op, new_op;
2370 bfd_size_type input_size;
2371 int r_type;
2372 unsigned dest_reg, src_reg;
2373
2374 if (ibuff == NULL)
2375 {
2376 ibuff = xtensa_insnbuf_alloc (isa);
2377 sbuff = xtensa_insnbuf_alloc (isa);
2378 }
2379
2380 input_size = bfd_get_section_limit (abfd, input_section);
2381
2382 /* Read the instruction into a buffer and decode the opcode. */
2383 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2384 input_size - rel->r_offset);
2385 fmt = xtensa_format_decode (isa, ibuff);
2386 if (fmt == XTENSA_UNDEFINED)
2387 {
2388 *error_message = "cannot decode instruction format";
2389 return FALSE;
2390 }
2391
2392 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2393 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2394
2395 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2396 if (old_op == XTENSA_UNDEFINED)
2397 {
2398 *error_message = "cannot decode instruction opcode";
2399 return FALSE;
2400 }
2401
2402 r_type = ELF32_R_TYPE (rel->r_info);
2403 switch (r_type)
2404 {
2405 case R_XTENSA_TLS_FUNC:
2406 case R_XTENSA_TLS_ARG:
2407 if (old_op != get_l32r_opcode ()
2408 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2409 sbuff, &dest_reg) != 0)
2410 {
2411 *error_message = "cannot extract L32R destination for TLS access";
2412 return FALSE;
2413 }
2414 break;
2415
2416 case R_XTENSA_TLS_CALL:
2417 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2418 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2419 sbuff, &src_reg) != 0)
2420 {
2421 *error_message = "cannot extract CALLXn operands for TLS access";
2422 return FALSE;
2423 }
2424 break;
2425
2426 default:
2427 abort ();
2428 }
2429
2430 if (is_ld_model)
2431 {
2432 switch (r_type)
2433 {
2434 case R_XTENSA_TLS_FUNC:
2435 case R_XTENSA_TLS_ARG:
2436 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2437 versions of Xtensa). */
2438 new_op = xtensa_opcode_lookup (isa, "nop");
2439 if (new_op == XTENSA_UNDEFINED)
2440 {
2441 new_op = xtensa_opcode_lookup (isa, "or");
2442 if (new_op == XTENSA_UNDEFINED
2443 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2444 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2445 sbuff, 1) != 0
2446 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2447 sbuff, 1) != 0
2448 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2449 sbuff, 1) != 0)
2450 {
2451 *error_message = "cannot encode OR for TLS access";
2452 return FALSE;
2453 }
2454 }
2455 else
2456 {
2457 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2458 {
2459 *error_message = "cannot encode NOP for TLS access";
2460 return FALSE;
2461 }
2462 }
2463 break;
2464
2465 case R_XTENSA_TLS_CALL:
2466 /* Read THREADPTR into the CALLX's return value register. */
2467 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2468 if (new_op == XTENSA_UNDEFINED
2469 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2470 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2471 sbuff, dest_reg + 2) != 0)
2472 {
2473 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2474 return FALSE;
2475 }
2476 break;
2477 }
2478 }
2479 else
2480 {
2481 switch (r_type)
2482 {
2483 case R_XTENSA_TLS_FUNC:
2484 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2485 if (new_op == XTENSA_UNDEFINED
2486 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2487 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2488 sbuff, dest_reg) != 0)
2489 {
2490 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2491 return FALSE;
2492 }
2493 break;
2494
2495 case R_XTENSA_TLS_ARG:
2496 /* Nothing to do. Keep the original L32R instruction. */
2497 return TRUE;
2498
2499 case R_XTENSA_TLS_CALL:
2500 /* Add the CALLX's src register (holding the THREADPTR value)
2501 to the first argument register (holding the offset) and put
2502 the result in the CALLX's return value register. */
2503 new_op = xtensa_opcode_lookup (isa, "add");
2504 if (new_op == XTENSA_UNDEFINED
2505 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2506 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2507 sbuff, dest_reg + 2) != 0
2508 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2509 sbuff, dest_reg + 2) != 0
2510 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2511 sbuff, src_reg) != 0)
2512 {
2513 *error_message = "cannot encode ADD for TLS access";
2514 return FALSE;
2515 }
2516 break;
2517 }
2518 }
2519
2520 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2521 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2522 input_size - rel->r_offset);
2523
2524 return TRUE;
2525}
2526
2527
2528#define IS_XTENSA_TLS_RELOC(R_TYPE) \
2529 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2530 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2531 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2532 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2533 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2534 || (R_TYPE) == R_XTENSA_TLS_ARG \
2535 || (R_TYPE) == R_XTENSA_TLS_CALL)
2536
e0001a05 2537/* Relocate an Xtensa ELF section. This is invoked by the linker for
1049f94e 2538 both relocatable and final links. */
e0001a05
NC		 2539
2540static bfd_boolean
7fa3d080
BW		 2541elf_xtensa_relocate_section (bfd *output_bfd,
2542 struct bfd_link_info *info,
2543 bfd *input_bfd,
2544 asection *input_section,
2545 bfd_byte *contents,
2546 Elf_Internal_Rela *relocs,
2547 Elf_Internal_Sym *local_syms,
2548 asection **local_sections)
e0001a05 2549{
f0e6fdb2 2550 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 2551 Elf_Internal_Shdr *symtab_hdr;
2552 Elf_Internal_Rela *rel;
2553 Elf_Internal_Rela *relend;
2554 struct elf_link_hash_entry **sym_hashes;
88d65ad6
BW		 2555 property_table_entry *lit_table = 0;
2556 int ltblsize = 0;
28dbbc02 2557 char *local_got_tls_types;
e0001a05 2558 char *error_message = NULL;
43cd72b9 2559 bfd_size_type input_size;
28dbbc02 2560 int tls_type;
e0001a05 2561
43cd72b9
BW		 2562 if (!xtensa_default_isa)
2563 xtensa_default_isa = xtensa_isa_init (0, 0);
e0001a05 2564
28dbbc02
BW		 2565 BFD_ASSERT (is_xtensa_elf (input_bfd));
2566
f0e6fdb2 2567 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 2568 if (htab == NULL)
2569 return FALSE;
2570
e0001a05
NC		 2571 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2572 sym_hashes = elf_sym_hashes (input_bfd);
28dbbc02 2573 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
e0001a05 2574
88d65ad6
BW		 2575 if (elf_hash_table (info)->dynamic_sections_created)
2576 {
2577 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
43cd72b9
BW		 2578 &lit_table, XTENSA_LIT_SEC_NAME,
2579 TRUE);
88d65ad6
BW		 2580 if (ltblsize < 0)
2581 return FALSE;
2582 }
2583
43cd72b9
BW		 2584 input_size = bfd_get_section_limit (input_bfd, input_section);
2585
e0001a05
NC		 2586 rel = relocs;
2587 relend = relocs + input_section->reloc_count;
2588 for (; rel < relend; rel++)
2589 {
2590 int r_type;
2591 reloc_howto_type *howto;
2592 unsigned long r_symndx;
2593 struct elf_link_hash_entry *h;
2594 Elf_Internal_Sym *sym;
28dbbc02
BW		 2595 char sym_type;
2596 const char *name;
e0001a05
NC		 2597 asection *sec;
2598 bfd_vma relocation;
2599 bfd_reloc_status_type r;
2600 bfd_boolean is_weak_undef;
2601 bfd_boolean unresolved_reloc;
9b8c98a4 2602 bfd_boolean warned;
28dbbc02 2603 bfd_boolean dynamic_symbol;
e0001a05
NC		 2604
2605 r_type = ELF32_R_TYPE (rel->r_info);
2606 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2607 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2608 continue;
2609
2610 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2611 {
2612 bfd_set_error (bfd_error_bad_value);
2613 return FALSE;
2614 }
2615 howto = &elf_howto_table[r_type];
2616
2617 r_symndx = ELF32_R_SYM (rel->r_info);
2618
ab96bf03
AM		 2619 h = NULL;
2620 sym = NULL;
2621 sec = NULL;
2622 is_weak_undef = FALSE;
2623 unresolved_reloc = FALSE;
2624 warned = FALSE;
2625
2626 if (howto->partial_inplace && !info->relocatable)
2627 {
2628 /* Because R_XTENSA_32 was made partial_inplace to fix some
2629 problems with DWARF info in partial links, there may be
2630 an addend stored in the contents. Take it out of there
2631 and move it back into the addend field of the reloc. */
2632 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2633 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2634 }
2635
2636 if (r_symndx < symtab_hdr->sh_info)
2637 {
2638 sym = local_syms + r_symndx;
28dbbc02 2639 sym_type = ELF32_ST_TYPE (sym->st_info);
ab96bf03
AM		 2640 sec = local_sections[r_symndx];
2641 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2642 }
2643 else
2644 {
62d887d4
L		 2645 bfd_boolean ignored;
2646
ab96bf03
AM		 2647 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2648 r_symndx, symtab_hdr, sym_hashes,
2649 h, sec, relocation,
62d887d4 2650 unresolved_reloc, warned, ignored);
ab96bf03
AM		 2651
2652 if (relocation == 0
2653 && !unresolved_reloc
2654 && h->root.type == bfd_link_hash_undefweak)
2655 is_weak_undef = TRUE;
28dbbc02
BW		 2656
2657 sym_type = h->type;
ab96bf03
AM		 2658 }
2659
dbaa2011 2660 if (sec != NULL && discarded_section (sec))
e4067dbb 2661 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 2662 rel, 1, relend, howto, 0, contents);
ab96bf03 2663
1049f94e 2664 if (info->relocatable)
e0001a05 2665 {
7aa09196
SA		 2666 bfd_vma dest_addr;
2667 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2668
43cd72b9 2669 /* This is a relocatable link.
e0001a05
NC		 2670 1) If the reloc is against a section symbol, adjust
2671 according to the output section.
2672 2) If there is a new target for this relocation,
2673 the new target will be in the same output section.
2674 We adjust the relocation by the output section
2675 difference. */
2676
2677 if (relaxing_section)
2678 {
2679 /* Check if this references a section in another input file. */
43cd72b9
BW		 2680 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2681 contents))
2682 return FALSE;
e0001a05
NC		 2683 }
2684
7aa09196
SA		 2685 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2686 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2687
43cd72b9 2688 if (r_type == R_XTENSA_ASM_SIMPLIFY)
e0001a05 2689 {
91d6fa6a 2690 error_message = NULL;
e0001a05
NC		 2691 /* Convert ASM_SIMPLIFY into the simpler relocation
2692 so that they never escape a relaxing link. */
43cd72b9
BW		 2693 r = contract_asm_expansion (contents, input_size, rel,
2694 &error_message);
2695 if (r != bfd_reloc_ok)
2696 {
2697 if (!((*info->callbacks->reloc_dangerous)
2698 (info, error_message, input_bfd, input_section,
2699 rel->r_offset)))
2700 return FALSE;
2701 }
e0001a05
NC		 2702 r_type = ELF32_R_TYPE (rel->r_info);
2703 }
2704
1049f94e 2705 /* This is a relocatable link, so we don't have to change
e0001a05
NC		 2706 anything unless the reloc is against a section symbol,
2707 in which case we have to adjust according to where the
2708 section symbol winds up in the output section. */
2709 if (r_symndx < symtab_hdr->sh_info)
2710 {
2711 sym = local_syms + r_symndx;
2712 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2713 {
2714 sec = local_sections[r_symndx];
2715 rel->r_addend += sec->output_offset + sym->st_value;
2716 }
2717 }
2718
2719 /* If there is an addend with a partial_inplace howto,
2720 then move the addend to the contents. This is a hack
1049f94e 2721 to work around problems with DWARF in relocatable links
e0001a05
NC		 2722 with some previous version of BFD. Now we can't easily get
2723 rid of the hack without breaking backward compatibility.... */
7aa09196
SA		 2724 r = bfd_reloc_ok;
2725 howto = &elf_howto_table[r_type];
2726 if (howto->partial_inplace && rel->r_addend)
2727 {
2728 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2729 rel->r_addend, contents,
2730 rel->r_offset, FALSE,
2731 &error_message);
2732 rel->r_addend = 0;
2733 }
2734 else
e0001a05 2735 {
7aa09196
SA		 2736 /* Put the correct bits in the target instruction, even
2737 though the relocation will still be present in the output
2738 file. This makes disassembly clearer, as well as
2739 allowing loadable kernel modules to work without needing
2740 relocations on anything other than calls and l32r's. */
2741
2742 /* If it is not in the same section, there is nothing we can do. */
2743 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2744 sym_sec->output_section == input_section->output_section)
e0001a05
NC		 2745 {
2746 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
7aa09196 2747 dest_addr, contents,
e0001a05
NC		 2748 rel->r_offset, FALSE,
2749 &error_message);
e0001a05
NC		 2750 }
2751 }
7aa09196
SA		 2752 if (r != bfd_reloc_ok)
2753 {
2754 if (!((*info->callbacks->reloc_dangerous)
2755 (info, error_message, input_bfd, input_section,
2756 rel->r_offset)))
2757 return FALSE;
2758 }
e0001a05 2759
1049f94e 2760 /* Done with work for relocatable link; continue with next reloc. */
e0001a05
NC		 2761 continue;
2762 }
2763
2764 /* This is a final link. */
2765
e0001a05
NC		 2766 if (relaxing_section)
2767 {
2768 /* Check if this references a section in another input file. */
43cd72b9
BW		 2769 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2770 &relocation);
e0001a05
NC		 2771 }
2772
2773 /* Sanity check the address. */
43cd72b9 2774 if (rel->r_offset >= input_size
e0001a05
NC		 2775 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2776 {
43cd72b9
BW		 2777 (*_bfd_error_handler)
2778 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2779 input_bfd, input_section, rel->r_offset, input_size);
e0001a05
NC		 2780 bfd_set_error (bfd_error_bad_value);
2781 return FALSE;
2782 }
2783
28dbbc02
BW		 2784 if (h != NULL)
2785 name = h->root.root.string;
2786 else
e0001a05 2787 {
28dbbc02
BW		 2788 name = (bfd_elf_string_from_elf_section
2789 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2790 if (name == NULL || *name == '\0')
2791 name = bfd_section_name (input_bfd, sec);
2792 }
e0001a05 2793
cf35638d 2794 if (r_symndx != STN_UNDEF
28dbbc02
BW		 2795 && r_type != R_XTENSA_NONE
2796 && (h == NULL
2797 || h->root.type == bfd_link_hash_defined
2798 || h->root.type == bfd_link_hash_defweak)
2799 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2800 {
2801 (*_bfd_error_handler)
2802 ((sym_type == STT_TLS
2803 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2804 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2805 input_bfd,
2806 input_section,
2807 (long) rel->r_offset,
2808 howto->name,
2809 name);
2810 }
2811
2812 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2813
2814 tls_type = GOT_UNKNOWN;
2815 if (h)
2816 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2817 else if (local_got_tls_types)
2818 tls_type = local_got_tls_types [r_symndx];
2819
2820 switch (r_type)
2821 {
2822 case R_XTENSA_32:
2823 case R_XTENSA_PLT:
2824 if (elf_hash_table (info)->dynamic_sections_created
2825 && (input_section->flags & SEC_ALLOC) != 0
2826 && (dynamic_symbol || info->shared))
e0001a05
NC		 2827 {
2828 Elf_Internal_Rela outrel;
2829 bfd_byte *loc;
2830 asection *srel;
2831
2832 if (dynamic_symbol && r_type == R_XTENSA_PLT)
f0e6fdb2 2833 srel = htab->srelplt;
e0001a05 2834 else
f0e6fdb2 2835 srel = htab->srelgot;
e0001a05
NC		 2836
2837 BFD_ASSERT (srel != NULL);
2838
2839 outrel.r_offset =
2840 _bfd_elf_section_offset (output_bfd, info,
2841 input_section, rel->r_offset);
2842
2843 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2844 memset (&outrel, 0, sizeof outrel);
2845 else
2846 {
f0578e28
BW		 2847 outrel.r_offset += (input_section->output_section->vma
2848 + input_section->output_offset);
e0001a05 2849
88d65ad6
BW		 2850 /* Complain if the relocation is in a read-only section
2851 and not in a literal pool. */
2852 if ((input_section->flags & SEC_READONLY) != 0
2853 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
3ba3bc8c 2854 outrel.r_offset))
88d65ad6
BW		 2855 {
2856 error_message =
2857 _("dynamic relocation in read-only section");
2858 if (!((*info->callbacks->reloc_dangerous)
2859 (info, error_message, input_bfd, input_section,
2860 rel->r_offset)))
2861 return FALSE;
2862 }
2863
e0001a05
NC		 2864 if (dynamic_symbol)
2865 {
2866 outrel.r_addend = rel->r_addend;
2867 rel->r_addend = 0;
2868
2869 if (r_type == R_XTENSA_32)
2870 {
2871 outrel.r_info =
2872 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2873 relocation = 0;
2874 }
2875 else /* r_type == R_XTENSA_PLT */
2876 {
2877 outrel.r_info =
2878 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2879
2880 /* Create the PLT entry and set the initial
2881 contents of the literal entry to the address of
2882 the PLT entry. */
43cd72b9 2883 relocation =
f0e6fdb2 2884 elf_xtensa_create_plt_entry (info, output_bfd,
e0001a05
NC		 2885 srel->reloc_count);
2886 }
2887 unresolved_reloc = FALSE;
2888 }
2889 else
2890 {
2891 /* Generate a RELATIVE relocation. */
2892 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2893 outrel.r_addend = 0;
2894 }
2895 }
2896
2897 loc = (srel->contents
2898 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2899 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2900 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
eea6121a 2901 <= srel->size);
e0001a05 2902 }
d9ab3f29
BW		 2903 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2904 {
2905 /* This should only happen for non-PIC code, which is not
2906 supposed to be used on systems with dynamic linking.
2907 Just ignore these relocations. */
2908 continue;
2909 }
28dbbc02
BW		 2910 break;
2911
2912 case R_XTENSA_TLS_TPOFF:
2913 /* Switch to LE model for local symbols in an executable. */
2914 if (! info->shared && ! dynamic_symbol)
2915 {
2916 relocation = tpoff (info, relocation);
2917 break;
2918 }
2919 /* fall through */
2920
2921 case R_XTENSA_TLSDESC_FN:
2922 case R_XTENSA_TLSDESC_ARG:
2923 {
2924 if (r_type == R_XTENSA_TLSDESC_FN)
2925 {
2926 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2927 r_type = R_XTENSA_NONE;
2928 }
2929 else if (r_type == R_XTENSA_TLSDESC_ARG)
2930 {
2931 if (info->shared)
2932 {
2933 if ((tls_type & GOT_TLS_IE) != 0)
2934 r_type = R_XTENSA_TLS_TPOFF;
2935 }
2936 else
2937 {
2938 r_type = R_XTENSA_TLS_TPOFF;
2939 if (! dynamic_symbol)
2940 {
2941 relocation = tpoff (info, relocation);
2942 break;
2943 }
2944 }
2945 }
2946
2947 if (r_type == R_XTENSA_NONE)
2948 /* Nothing to do here; skip to the next reloc. */
2949 continue;
2950
2951 if (! elf_hash_table (info)->dynamic_sections_created)
2952 {
2953 error_message =
2954 _("TLS relocation invalid without dynamic sections");
2955 if (!((*info->callbacks->reloc_dangerous)
2956 (info, error_message, input_bfd, input_section,
2957 rel->r_offset)))
2958 return FALSE;
2959 }
2960 else
2961 {
2962 Elf_Internal_Rela outrel;
2963 bfd_byte *loc;
2964 asection *srel = htab->srelgot;
2965 int indx;
2966
2967 outrel.r_offset = (input_section->output_section->vma
2968 + input_section->output_offset
2969 + rel->r_offset);
2970
2971 /* Complain if the relocation is in a read-only section
2972 and not in a literal pool. */
2973 if ((input_section->flags & SEC_READONLY) != 0
2974 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2975 outrel.r_offset))
2976 {
2977 error_message =
2978 _("dynamic relocation in read-only section");
2979 if (!((*info->callbacks->reloc_dangerous)
2980 (info, error_message, input_bfd, input_section,
2981 rel->r_offset)))
2982 return FALSE;
2983 }
2984
2985 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2986 if (indx == 0)
2987 outrel.r_addend = relocation - dtpoff_base (info);
2988 else
2989 outrel.r_addend = 0;
2990 rel->r_addend = 0;
2991
2992 outrel.r_info = ELF32_R_INFO (indx, r_type);
2993 relocation = 0;
2994 unresolved_reloc = FALSE;
2995
2996 BFD_ASSERT (srel);
2997 loc = (srel->contents
2998 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2999 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3000 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3001 <= srel->size);
3002 }
3003 }
3004 break;
3005
3006 case R_XTENSA_TLS_DTPOFF:
3007 if (! info->shared)
3008 /* Switch from LD model to LE model. */
3009 relocation = tpoff (info, relocation);
3010 else
3011 relocation -= dtpoff_base (info);
3012 break;
3013
3014 case R_XTENSA_TLS_FUNC:
3015 case R_XTENSA_TLS_ARG:
3016 case R_XTENSA_TLS_CALL:
3017 /* Check if optimizing to IE or LE model. */
3018 if ((tls_type & GOT_TLS_IE) != 0)
3019 {
3020 bfd_boolean is_ld_model =
3021 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3022 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3023 is_ld_model, &error_message))
3024 {
3025 if (!((*info->callbacks->reloc_dangerous)
3026 (info, error_message, input_bfd, input_section,
3027 rel->r_offset)))
3028 return FALSE;
3029 }
3030
3031 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3032 {
3033 /* Skip subsequent relocations on the same instruction. */
3034 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3035 rel++;
3036 }
3037 }
3038 continue;
3039
3040 default:
3041 if (elf_hash_table (info)->dynamic_sections_created
3042 && dynamic_symbol && (is_operand_relocation (r_type)
3043 || r_type == R_XTENSA_32_PCREL))
3044 {
3045 error_message =
3046 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3047 strlen (name) + 2, name);
3048 if (!((*info->callbacks->reloc_dangerous)
3049 (info, error_message, input_bfd, input_section,
3050 rel->r_offset)))
3051 return FALSE;
3052 continue;
3053 }
3054 break;
e0001a05
NC		 3055 }
3056
3057 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3058 because such sections are not SEC_ALLOC and thus ld.so will
3059 not process them. */
3060 if (unresolved_reloc
3061 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 3062 && h->def_dynamic)
3063 && _bfd_elf_section_offset (output_bfd, info, input_section,
3064 rel->r_offset) != (bfd_vma) -1)
bf1747de
BW		 3065 {
3066 (*_bfd_error_handler)
3067 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3068 input_bfd,
3069 input_section,
3070 (long) rel->r_offset,
3071 howto->name,
28dbbc02 3072 name);
bf1747de
BW		 3073 return FALSE;
3074 }
e0001a05 3075
28dbbc02
BW		 3076 /* TLS optimizations may have changed r_type; update "howto". */
3077 howto = &elf_howto_table[r_type];
3078
e0001a05
NC		 3079 /* There's no point in calling bfd_perform_relocation here.
3080 Just go directly to our "special function". */
3081 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3082 relocation + rel->r_addend,
3083 contents, rel->r_offset, is_weak_undef,
3084 &error_message);
43cd72b9 3085
9b8c98a4 3086 if (r != bfd_reloc_ok && !warned)
e0001a05 3087 {
43cd72b9 3088 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
7fa3d080 3089 BFD_ASSERT (error_message != NULL);
e0001a05 3090
28dbbc02
BW		 3091 if (rel->r_addend == 0)
3092 error_message = vsprint_msg (error_message, ": %s",
3093 strlen (name) + 2, name);
e0001a05 3094 else
28dbbc02
BW		 3095 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3096 strlen (name) + 22,
3097 name, (int) rel->r_addend);
43cd72b9 3098
e0001a05
NC		 3099 if (!((*info->callbacks->reloc_dangerous)
3100 (info, error_message, input_bfd, input_section,
3101 rel->r_offset)))
3102 return FALSE;
3103 }
3104 }
3105
88d65ad6
BW		 3106 if (lit_table)
3107 free (lit_table);
3108
3ba3bc8c
BW		 3109 input_section->reloc_done = TRUE;
3110
e0001a05
NC		 3111 return TRUE;
3112}
3113
3114
3115/* Finish up dynamic symbol handling. There's not much to do here since
3116 the PLT and GOT entries are all set up by relocate_section. */
3117
3118static bfd_boolean
7fa3d080
BW		 3119elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3120 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3121 struct elf_link_hash_entry *h,
3122 Elf_Internal_Sym *sym)
e0001a05 3123{
bf1747de 3124 if (h->needs_plt && !h->def_regular)
e0001a05
NC		 3125 {
3126 /* Mark the symbol as undefined, rather than as defined in
3127 the .plt section. Leave the value alone. */
3128 sym->st_shndx = SHN_UNDEF;
bf1747de
BW		 3129 /* If the symbol is weak, we do need to clear the value.
3130 Otherwise, the PLT entry would provide a definition for
3131 the symbol even if the symbol wasn't defined anywhere,
3132 and so the symbol would never be NULL. */
3133 if (!h->ref_regular_nonweak)
3134 sym->st_value = 0;
e0001a05
NC		 3135 }
3136
3137 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
9637f6ef 3138 if (h == elf_hash_table (info)->hdynamic
22edb2f1 3139 || h == elf_hash_table (info)->hgot)
e0001a05
NC		 3140 sym->st_shndx = SHN_ABS;
3141
3142 return TRUE;
3143}
3144
3145
3146/* Combine adjacent literal table entries in the output. Adjacent
3147 entries within each input section may have been removed during
3148 relaxation, but we repeat the process here, even though it's too late
3149 to shrink the output section, because it's important to minimize the
3150 number of literal table entries to reduce the start-up work for the
3151 runtime linker. Returns the number of remaining table entries or -1
3152 on error. */
3153
3154static int
7fa3d080
BW		 3155elf_xtensa_combine_prop_entries (bfd *output_bfd,
3156 asection *sxtlit,
3157 asection *sgotloc)
e0001a05 3158{
e0001a05
NC		 3159 bfd_byte *contents;
3160 property_table_entry *table;
e901de89 3161 bfd_size_type section_size, sgotloc_size;
e0001a05
NC		 3162 bfd_vma offset;
3163 int n, m, num;
3164
eea6121a 3165 section_size = sxtlit->size;
e0001a05
NC		 3166 BFD_ASSERT (section_size % 8 == 0);
3167 num = section_size / 8;
3168
eea6121a 3169 sgotloc_size = sgotloc->size;
e901de89 3170 if (sgotloc_size != section_size)
b536dc1e
BW		 3171 {
3172 (*_bfd_error_handler)
43cd72b9 3173 (_("internal inconsistency in size of .got.loc section"));
b536dc1e
BW		 3174 return -1;
3175 }
e901de89 3176
eea6121a
AM		 3177 table = bfd_malloc (num * sizeof (property_table_entry));
3178 if (table == 0)
e0001a05
NC		 3179 return -1;
3180
3181 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3182 propagates to the output section, where it doesn't really apply and
eea6121a 3183 where it breaks the following call to bfd_malloc_and_get_section. */
e901de89 3184 sxtlit->flags &= ~SEC_IN_MEMORY;
e0001a05 3185
eea6121a
AM		 3186 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3187 {
3188 if (contents != 0)
3189 free (contents);
3190 free (table);
3191 return -1;
3192 }
e0001a05
NC		 3193
3194 /* There should never be any relocations left at this point, so this
3195 is quite a bit easier than what is done during relaxation. */
3196
3197 /* Copy the raw contents into a property table array and sort it. */
3198 offset = 0;
3199 for (n = 0; n < num; n++)
3200 {
3201 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3202 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3203 offset += 8;
3204 }
3205 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3206
3207 for (n = 0; n < num; n++)
3208 {
91d6fa6a 3209 bfd_boolean remove_entry = FALSE;
e0001a05
NC		 3210
3211 if (table[n].size == 0)
91d6fa6a
NC		 3212 remove_entry = TRUE;
3213 else if (n > 0
3214 && (table[n-1].address + table[n-1].size == table[n].address))
e0001a05
NC		 3215 {
3216 table[n-1].size += table[n].size;
91d6fa6a 3217 remove_entry = TRUE;
e0001a05
NC		 3218 }
3219
91d6fa6a 3220 if (remove_entry)
e0001a05
NC		 3221 {
3222 for (m = n; m < num - 1; m++)
3223 {
3224 table[m].address = table[m+1].address;
3225 table[m].size = table[m+1].size;
3226 }
3227
3228 n--;
3229 num--;
3230 }
3231 }
3232
3233 /* Copy the data back to the raw contents. */
3234 offset = 0;
3235 for (n = 0; n < num; n++)
3236 {
3237 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3238 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3239 offset += 8;
3240 }
3241
3242 /* Clear the removed bytes. */
3243 if ((bfd_size_type) (num * 8) < section_size)
b54d4b07 3244 memset (&contents[num * 8], 0, section_size - num * 8);
e0001a05 3245
e901de89
BW		 3246 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3247 section_size))
e0001a05
NC		 3248 return -1;
3249
e901de89
BW		 3250 /* Copy the contents to ".got.loc". */
3251 memcpy (sgotloc->contents, contents, section_size);
3252
e0001a05 3253 free (contents);
b614a702 3254 free (table);
e0001a05
NC		 3255 return num;
3256}
3257
3258
3259/* Finish up the dynamic sections. */
3260
3261static bfd_boolean
7fa3d080
BW		 3262elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3263 struct bfd_link_info *info)
e0001a05 3264{
f0e6fdb2 3265 struct elf_xtensa_link_hash_table *htab;
e0001a05 3266 bfd *dynobj;
e901de89 3267 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
e0001a05 3268 Elf32_External_Dyn *dyncon, *dynconend;
d9ab3f29 3269 int num_xtlit_entries = 0;
e0001a05
NC		 3270
3271 if (! elf_hash_table (info)->dynamic_sections_created)
3272 return TRUE;
3273
f0e6fdb2 3274 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 3275 if (htab == NULL)
3276 return FALSE;
3277
e0001a05 3278 dynobj = elf_hash_table (info)->dynobj;
3d4d4302 3279 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
e0001a05
NC		 3280 BFD_ASSERT (sdyn != NULL);
3281
3282 /* Set the first entry in the global offset table to the address of
3283 the dynamic section. */
f0e6fdb2 3284 sgot = htab->sgot;
e0001a05
NC		 3285 if (sgot)
3286 {
eea6121a 3287 BFD_ASSERT (sgot->size == 4);
e0001a05 3288 if (sdyn == NULL)
7fa3d080 3289 bfd_put_32 (output_bfd, 0, sgot->contents);
e0001a05
NC		 3290 else
3291 bfd_put_32 (output_bfd,
3292 sdyn->output_section->vma + sdyn->output_offset,
3293 sgot->contents);
3294 }
3295
f0e6fdb2 3296 srelplt = htab->srelplt;
7fa3d080 3297 if (srelplt && srelplt->size != 0)
e0001a05
NC		 3298 {
3299 asection *sgotplt, *srelgot, *spltlittbl;
3300 int chunk, plt_chunks, plt_entries;
3301 Elf_Internal_Rela irela;
3302 bfd_byte *loc;
3303 unsigned rtld_reloc;
3304
f0e6fdb2
BW		 3305 srelgot = htab->srelgot;
3306 spltlittbl = htab->spltlittbl;
3307 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
e0001a05
NC		 3308
3309 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3310 of them follow immediately after.... */
3311 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3312 {
3313 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3314 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3315 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3316 break;
3317 }
3318 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3319
eea6121a 3320 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 3321 plt_chunks =
3322 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3323
3324 for (chunk = 0; chunk < plt_chunks; chunk++)
3325 {
3326 int chunk_entries = 0;
3327
f0e6fdb2 3328 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 3329 BFD_ASSERT (sgotplt != NULL);
3330
3331 /* Emit special RTLD relocations for the first two entries in
3332 each chunk of the .got.plt section. */
3333
3334 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3335 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3336 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3337 irela.r_offset = (sgotplt->output_section->vma
3338 + sgotplt->output_offset);
3339 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3340 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3341 rtld_reloc += 1;
3342 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3343
3344 /* Next literal immediately follows the first. */
3345 loc += sizeof (Elf32_External_Rela);
3346 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3347 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3348 irela.r_offset = (sgotplt->output_section->vma
3349 + sgotplt->output_offset + 4);
3350 /* Tell rtld to set value to object's link map. */
3351 irela.r_addend = 2;
3352 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3353 rtld_reloc += 1;
3354 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3355
3356 /* Fill in the literal table. */
3357 if (chunk < plt_chunks - 1)
3358 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3359 else
3360 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3361
eea6121a 3362 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
e0001a05
NC		 3363 bfd_put_32 (output_bfd,
3364 sgotplt->output_section->vma + sgotplt->output_offset,
3365 spltlittbl->contents + (chunk * 8) + 0);
3366 bfd_put_32 (output_bfd,
3367 8 + (chunk_entries * 4),
3368 spltlittbl->contents + (chunk * 8) + 4);
3369 }
3370
3371 /* All the dynamic relocations have been emitted at this point.
3372 Make sure the relocation sections are the correct size. */
eea6121a
AM		 3373 if (srelgot->size != (sizeof (Elf32_External_Rela)
3374 * srelgot->reloc_count)
3375 || srelplt->size != (sizeof (Elf32_External_Rela)
3376 * srelplt->reloc_count))
e0001a05
NC		 3377 abort ();
3378
3379 /* The .xt.lit.plt section has just been modified. This must
3380 happen before the code below which combines adjacent literal
3381 table entries, and the .xt.lit.plt contents have to be forced to
3382 the output here. */
3383 if (! bfd_set_section_contents (output_bfd,
3384 spltlittbl->output_section,
3385 spltlittbl->contents,
3386 spltlittbl->output_offset,
eea6121a 3387 spltlittbl->size))
e0001a05
NC		 3388 return FALSE;
3389 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3390 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3391 }
3392
3393 /* Combine adjacent literal table entries. */
1049f94e 3394 BFD_ASSERT (! info->relocatable);
e901de89 3395 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
f0e6fdb2 3396 sgotloc = htab->sgotloc;
d9ab3f29
BW		 3397 BFD_ASSERT (sgotloc);
3398 if (sxtlit)
3399 {
3400 num_xtlit_entries =
3401 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3402 if (num_xtlit_entries < 0)
3403 return FALSE;
3404 }
e0001a05
NC		 3405
3406 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 3407 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
e0001a05
NC		 3408 for (; dyncon < dynconend; dyncon++)
3409 {
3410 Elf_Internal_Dyn dyn;
e0001a05
NC		 3411
3412 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3413
3414 switch (dyn.d_tag)
3415 {
3416 default:
3417 break;
3418
3419 case DT_XTENSA_GOT_LOC_SZ:
e0001a05
NC		 3420 dyn.d_un.d_val = num_xtlit_entries;
3421 break;
3422
3423 case DT_XTENSA_GOT_LOC_OFF:
e29297b7 3424 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
f0e6fdb2
BW		 3425 break;
3426
e0001a05 3427 case DT_PLTGOT:
e29297b7 3428 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
f0e6fdb2
BW		 3429 break;
3430
e0001a05 3431 case DT_JMPREL:
e29297b7 3432 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
e0001a05
NC		 3433 break;
3434
3435 case DT_PLTRELSZ:
e29297b7 3436 dyn.d_un.d_val = htab->srelplt->output_section->size;
e0001a05
NC		 3437 break;
3438
3439 case DT_RELASZ:
3440 /* Adjust RELASZ to not include JMPREL. This matches what
3441 glibc expects and what is done for several other ELF
3442 targets (e.g., i386, alpha), but the "correct" behavior
3443 seems to be unresolved. Since the linker script arranges
3444 for .rela.plt to follow all other relocation sections, we
3445 don't have to worry about changing the DT_RELA entry. */
f0e6fdb2 3446 if (htab->srelplt)
e29297b7 3447 dyn.d_un.d_val -= htab->srelplt->output_section->size;
e0001a05
NC		 3448 break;
3449 }
3450
3451 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3452 }
3453
3454 return TRUE;
3455}
3456
3457\f
3458/* Functions for dealing with the e_flags field. */
3459
3460/* Merge backend specific data from an object file to the output
3461 object file when linking. */
3462
3463static bfd_boolean
7fa3d080 3464elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
e0001a05
NC		 3465{
3466 unsigned out_mach, in_mach;
3467 flagword out_flag, in_flag;
3468
cc643b88 3469 /* Check if we have the same endianness. */
e0001a05
NC		 3470 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3471 return FALSE;
3472
3473 /* Don't even pretend to support mixed-format linking. */
3474 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3475 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3476 return FALSE;
3477
3478 out_flag = elf_elfheader (obfd)->e_flags;
3479 in_flag = elf_elfheader (ibfd)->e_flags;
3480
3481 out_mach = out_flag & EF_XTENSA_MACH;
3482 in_mach = in_flag & EF_XTENSA_MACH;
43cd72b9 3483 if (out_mach != in_mach)
e0001a05
NC		 3484 {
3485 (*_bfd_error_handler)
43cd72b9 3486 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
d003868e 3487 ibfd, out_mach, in_mach);
e0001a05
NC		 3488 bfd_set_error (bfd_error_wrong_format);
3489 return FALSE;
3490 }
3491
3492 if (! elf_flags_init (obfd))
3493 {
3494 elf_flags_init (obfd) = TRUE;
3495 elf_elfheader (obfd)->e_flags = in_flag;
43cd72b9 3496
e0001a05
NC		 3497 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3498 && bfd_get_arch_info (obfd)->the_default)
3499 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3500 bfd_get_mach (ibfd));
43cd72b9 3501
e0001a05
NC		 3502 return TRUE;
3503 }
3504
68ffbac6 3505 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
43cd72b9 3506 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
e0001a05 3507
68ffbac6 3508 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
43cd72b9 3509 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
e0001a05
NC		 3510
3511 return TRUE;
3512}
3513
3514
3515static bfd_boolean
7fa3d080 3516elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
e0001a05
NC		 3517{
3518 BFD_ASSERT (!elf_flags_init (abfd)
3519 || elf_elfheader (abfd)->e_flags == flags);
3520
3521 elf_elfheader (abfd)->e_flags |= flags;
3522 elf_flags_init (abfd) = TRUE;
3523
3524 return TRUE;
3525}
3526
3527
e0001a05 3528static bfd_boolean
7fa3d080 3529elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
e0001a05
NC		 3530{
3531 FILE *f = (FILE *) farg;
3532 flagword e_flags = elf_elfheader (abfd)->e_flags;
3533
3534 fprintf (f, "\nXtensa header:\n");
43cd72b9 3535 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
e0001a05
NC		 3536 fprintf (f, "\nMachine = Base\n");
3537 else
3538 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3539
3540 fprintf (f, "Insn tables = %s\n",
3541 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3542
3543 fprintf (f, "Literal tables = %s\n",
3544 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3545
3546 return _bfd_elf_print_private_bfd_data (abfd, farg);
3547}
3548
3549
3550/* Set the right machine number for an Xtensa ELF file. */
3551
3552static bfd_boolean
7fa3d080 3553elf_xtensa_object_p (bfd *abfd)
e0001a05
NC		 3554{
3555 int mach;
3556 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3557
3558 switch (arch)
3559 {
3560 case E_XTENSA_MACH:
3561 mach = bfd_mach_xtensa;
3562 break;
3563 default:
3564 return FALSE;
3565 }
3566
3567 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3568 return TRUE;
3569}
3570
3571
3572/* The final processing done just before writing out an Xtensa ELF object
3573 file. This gets the Xtensa architecture right based on the machine
3574 number. */
3575
3576static void
7fa3d080
BW		 3577elf_xtensa_final_write_processing (bfd *abfd,
3578 bfd_boolean linker ATTRIBUTE_UNUSED)
e0001a05
NC		 3579{
3580 int mach;
3581 unsigned long val;
3582
3583 switch (mach = bfd_get_mach (abfd))
3584 {
3585 case bfd_mach_xtensa:
3586 val = E_XTENSA_MACH;
3587 break;
3588 default:
3589 return;
3590 }
3591
3592 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3593 elf_elfheader (abfd)->e_flags |= val;
3594}
3595
3596
3597static enum elf_reloc_type_class
7e612e98
AM		 3598elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3599 const asection *rel_sec ATTRIBUTE_UNUSED,
3600 const Elf_Internal_Rela *rela)
e0001a05
NC		 3601{
3602 switch ((int) ELF32_R_TYPE (rela->r_info))
3603 {
3604 case R_XTENSA_RELATIVE:
3605 return reloc_class_relative;
3606 case R_XTENSA_JMP_SLOT:
3607 return reloc_class_plt;
3608 default:
3609 return reloc_class_normal;
3610 }
3611}
3612
3613\f
3614static bfd_boolean
7fa3d080
BW		 3615elf_xtensa_discard_info_for_section (bfd *abfd,
3616 struct elf_reloc_cookie *cookie,
3617 struct bfd_link_info *info,
3618 asection *sec)
e0001a05
NC		 3619{
3620 bfd_byte *contents;
e0001a05 3621 bfd_vma offset, actual_offset;
1d25768e
BW		 3622 bfd_size_type removed_bytes = 0;
3623 bfd_size_type entry_size;
e0001a05
NC		 3624
3625 if (sec->output_section
3626 && bfd_is_abs_section (sec->output_section))
3627 return FALSE;
3628
1d25768e
BW		 3629 if (xtensa_is_proptable_section (sec))
3630 entry_size = 12;
3631 else
3632 entry_size = 8;
3633
a3ef2d63 3634 if (sec->size == 0 || sec->size % entry_size != 0)
1d25768e
BW		 3635 return FALSE;
3636
e0001a05
NC		 3637 contents = retrieve_contents (abfd, sec, info->keep_memory);
3638 if (!contents)
3639 return FALSE;
3640
3641 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3642 if (!cookie->rels)
3643 {
3644 release_contents (sec, contents);
3645 return FALSE;
3646 }
3647
1d25768e
BW		 3648 /* Sort the relocations. They should already be in order when
3649 relaxation is enabled, but it might not be. */
3650 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3651 internal_reloc_compare);
3652
e0001a05
NC		 3653 cookie->rel = cookie->rels;
3654 cookie->relend = cookie->rels + sec->reloc_count;
3655
a3ef2d63 3656 for (offset = 0; offset < sec->size; offset += entry_size)
e0001a05
NC		 3657 {
3658 actual_offset = offset - removed_bytes;
3659
3660 /* The ...symbol_deleted_p function will skip over relocs but it
3661 won't adjust their offsets, so do that here. */
3662 while (cookie->rel < cookie->relend
3663 && cookie->rel->r_offset < offset)
3664 {
3665 cookie->rel->r_offset -= removed_bytes;
3666 cookie->rel++;
3667 }
3668
3669 while (cookie->rel < cookie->relend
3670 && cookie->rel->r_offset == offset)
3671 {
c152c796 3672 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
e0001a05
NC		 3673 {
3674 /* Remove the table entry. (If the reloc type is NONE, then
3675 the entry has already been merged with another and deleted
3676 during relaxation.) */
3677 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3678 {
3679 /* Shift the contents up. */
a3ef2d63 3680 if (offset + entry_size < sec->size)
e0001a05 3681 memmove (&contents[actual_offset],
1d25768e 3682 &contents[actual_offset + entry_size],
a3ef2d63 3683 sec->size - offset - entry_size);
1d25768e 3684 removed_bytes += entry_size;
e0001a05
NC		 3685 }
3686
3687 /* Remove this relocation. */
3688 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3689 }
3690
3691 /* Adjust the relocation offset for previous removals. This
3692 should not be done before calling ...symbol_deleted_p
3693 because it might mess up the offset comparisons there.
3694 Make sure the offset doesn't underflow in the case where
3695 the first entry is removed. */
3696 if (cookie->rel->r_offset >= removed_bytes)
3697 cookie->rel->r_offset -= removed_bytes;
3698 else
3699 cookie->rel->r_offset = 0;
3700
3701 cookie->rel++;
3702 }
3703 }
3704
3705 if (removed_bytes != 0)
3706 {
3707 /* Adjust any remaining relocs (shouldn't be any). */
3708 for (; cookie->rel < cookie->relend; cookie->rel++)
3709 {
3710 if (cookie->rel->r_offset >= removed_bytes)
3711 cookie->rel->r_offset -= removed_bytes;
3712 else
3713 cookie->rel->r_offset = 0;
3714 }
3715
3716 /* Clear the removed bytes. */
a3ef2d63 3717 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
e0001a05
NC		 3718
3719 pin_contents (sec, contents);
3720 pin_internal_relocs (sec, cookie->rels);
3721
eea6121a 3722 /* Shrink size. */
a3ef2d63
BW		 3723 if (sec->rawsize == 0)
3724 sec->rawsize = sec->size;
3725 sec->size -= removed_bytes;
b536dc1e
BW		 3726
3727 if (xtensa_is_littable_section (sec))
3728 {
f0e6fdb2
BW		 3729 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3730 if (sgotloc)
3731 sgotloc->size -= removed_bytes;
b536dc1e 3732 }
e0001a05
NC		 3733 }
3734 else
3735 {
3736 release_contents (sec, contents);
3737 release_internal_relocs (sec, cookie->rels);
3738 }
3739
3740 return (removed_bytes != 0);
3741}
3742
3743
3744static bfd_boolean
7fa3d080
BW		 3745elf_xtensa_discard_info (bfd *abfd,
3746 struct elf_reloc_cookie *cookie,
3747 struct bfd_link_info *info)
e0001a05
NC		 3748{
3749 asection *sec;
3750 bfd_boolean changed = FALSE;
3751
3752 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3753 {
3754 if (xtensa_is_property_section (sec))
3755 {
3756 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3757 changed = TRUE;
3758 }
3759 }
3760
3761 return changed;
3762}
3763
3764
3765static bfd_boolean
7fa3d080 3766elf_xtensa_ignore_discarded_relocs (asection *sec)
e0001a05
NC		 3767{
3768 return xtensa_is_property_section (sec);
3769}
3770
a77dc2cc
BW		 3771
3772static unsigned int
3773elf_xtensa_action_discarded (asection *sec)
3774{
3775 if (strcmp (".xt_except_table", sec->name) == 0)
3776 return 0;
3777
3778 if (strcmp (".xt_except_desc", sec->name) == 0)
3779 return 0;
3780
3781 return _bfd_elf_default_action_discarded (sec);
3782}
3783
e0001a05
NC		 3784\f
3785/* Support for core dump NOTE sections. */
3786
3787static bfd_boolean
7fa3d080 3788elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
e0001a05
NC		 3789{
3790 int offset;
eea6121a 3791 unsigned int size;
e0001a05
NC		 3792
3793 /* The size for Xtensa is variable, so don't try to recognize the format
3794 based on the size. Just assume this is GNU/Linux. */
3795
3796 /* pr_cursig */
228e534f 3797 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
e0001a05
NC		 3798
3799 /* pr_pid */
228e534f 3800 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
e0001a05
NC		 3801
3802 /* pr_reg */
3803 offset = 72;
eea6121a 3804 size = note->descsz - offset - 4;
e0001a05
NC		 3805
3806 /* Make a ".reg/999" section. */
3807 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 3808 size, note->descpos + offset);
e0001a05
NC		 3809}
3810
3811
3812static bfd_boolean
7fa3d080 3813elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
e0001a05
NC		 3814{
3815 switch (note->descsz)
3816 {
3817 default:
3818 return FALSE;
3819
3820 case 128: /* GNU/Linux elf_prpsinfo */
228e534f 3821 elf_tdata (abfd)->core->program
e0001a05 3822 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
228e534f 3823 elf_tdata (abfd)->core->command
e0001a05
NC		 3824 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3825 }
3826
3827 /* Note that for some reason, a spurious space is tacked
3828 onto the end of the args in some (at least one anyway)
3829 implementations, so strip it off if it exists. */
3830
3831 {
228e534f 3832 char *command = elf_tdata (abfd)->core->command;
e0001a05
NC		 3833 int n = strlen (command);
3834
3835 if (0 < n && command[n - 1] == ' ')
3836 command[n - 1] = '\0';
3837 }
3838
3839 return TRUE;
3840}
3841
3842\f
3843/* Generic Xtensa configurability stuff. */
3844
3845static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3846static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3847static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3848static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3849static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3850static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3851static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3852static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3853
3854static void
7fa3d080 3855init_call_opcodes (void)
e0001a05
NC		 3856{
3857 if (callx0_op == XTENSA_UNDEFINED)
3858 {
3859 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3860 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3861 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3862 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3863 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3864 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3865 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3866 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3867 }
3868}
3869
3870
3871static bfd_boolean
7fa3d080 3872is_indirect_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3873{
3874 init_call_opcodes ();
3875 return (opcode == callx0_op
3876 || opcode == callx4_op
3877 || opcode == callx8_op
3878 || opcode == callx12_op);
3879}
3880
3881
3882static bfd_boolean
7fa3d080 3883is_direct_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3884{
3885 init_call_opcodes ();
3886 return (opcode == call0_op
3887 || opcode == call4_op
3888 || opcode == call8_op
3889 || opcode == call12_op);
3890}
3891
3892
3893static bfd_boolean
7fa3d080 3894is_windowed_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3895{
3896 init_call_opcodes ();
3897 return (opcode == call4_op
3898 || opcode == call8_op
3899 || opcode == call12_op
3900 || opcode == callx4_op
3901 || opcode == callx8_op
3902 || opcode == callx12_op);
3903}
3904
3905
28dbbc02
BW		 3906static bfd_boolean
3907get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3908{
3909 unsigned dst = (unsigned) -1;
3910
3911 init_call_opcodes ();
3912 if (opcode == callx0_op)
3913 dst = 0;
3914 else if (opcode == callx4_op)
3915 dst = 4;
3916 else if (opcode == callx8_op)
3917 dst = 8;
3918 else if (opcode == callx12_op)
3919 dst = 12;
3920
3921 if (dst == (unsigned) -1)
3922 return FALSE;
3923
3924 *pdst = dst;
3925 return TRUE;
3926}
3927
3928
43cd72b9
BW		 3929static xtensa_opcode
3930get_const16_opcode (void)
3931{
3932 static bfd_boolean done_lookup = FALSE;
3933 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3934 if (!done_lookup)
3935 {
3936 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3937 done_lookup = TRUE;
3938 }
3939 return const16_opcode;
3940}
3941
3942
e0001a05
NC		 3943static xtensa_opcode
3944get_l32r_opcode (void)
3945{
3946 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
43cd72b9
BW		 3947 static bfd_boolean done_lookup = FALSE;
3948
3949 if (!done_lookup)
e0001a05
NC		 3950 {
3951 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
43cd72b9 3952 done_lookup = TRUE;
e0001a05
NC		 3953 }
3954 return l32r_opcode;
3955}
3956
3957
3958static bfd_vma
7fa3d080 3959l32r_offset (bfd_vma addr, bfd_vma pc)
e0001a05
NC		 3960{
3961 bfd_vma offset;
3962
3963 offset = addr - ((pc+3) & -4);
3964 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3965 offset = (signed int) offset >> 2;
3966 BFD_ASSERT ((signed int) offset >> 16 == -1);
3967 return offset;
3968}
3969
3970
e0001a05 3971static int
7fa3d080 3972get_relocation_opnd (xtensa_opcode opcode, int r_type)
e0001a05 3973{
43cd72b9
BW		 3974 xtensa_isa isa = xtensa_default_isa;
3975 int last_immed, last_opnd, opi;
3976
3977 if (opcode == XTENSA_UNDEFINED)
3978 return XTENSA_UNDEFINED;
3979
3980 /* Find the last visible PC-relative immediate operand for the opcode.
3981 If there are no PC-relative immediates, then choose the last visible
3982 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3983 last_immed = XTENSA_UNDEFINED;
3984 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3985 for (opi = last_opnd - 1; opi >= 0; opi--)
3986 {
3987 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3988 continue;
3989 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3990 {
3991 last_immed = opi;
3992 break;
3993 }
3994 if (last_immed == XTENSA_UNDEFINED
3995 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3996 last_immed = opi;
3997 }
3998 if (last_immed < 0)
3999 return XTENSA_UNDEFINED;
4000
4001 /* If the operand number was specified in an old-style relocation,
4002 check for consistency with the operand computed above. */
4003 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4004 {
4005 int reloc_opnd = r_type - R_XTENSA_OP0;
4006 if (reloc_opnd != last_immed)
4007 return XTENSA_UNDEFINED;
4008 }
4009
4010 return last_immed;
4011}
4012
4013
4014int
7fa3d080 4015get_relocation_slot (int r_type)
43cd72b9
BW		 4016{
4017 switch (r_type)
4018 {
4019 case R_XTENSA_OP0:
4020 case R_XTENSA_OP1:
4021 case R_XTENSA_OP2:
4022 return 0;
4023
4024 default:
4025 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4026 return r_type - R_XTENSA_SLOT0_OP;
4027 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4028 return r_type - R_XTENSA_SLOT0_ALT;
4029 break;
4030 }
4031
4032 return XTENSA_UNDEFINED;
e0001a05
NC		 4033}
4034
4035
4036/* Get the opcode for a relocation. */
4037
4038static xtensa_opcode
7fa3d080
BW		 4039get_relocation_opcode (bfd *abfd,
4040 asection *sec,
4041 bfd_byte *contents,
4042 Elf_Internal_Rela *irel)
e0001a05
NC		 4043{
4044 static xtensa_insnbuf ibuff = NULL;
43cd72b9 4045 static xtensa_insnbuf sbuff = NULL;
e0001a05 4046 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 4047 xtensa_format fmt;
4048 int slot;
e0001a05
NC		 4049
4050 if (contents == NULL)
4051 return XTENSA_UNDEFINED;
4052
43cd72b9 4053 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
e0001a05
NC		 4054 return XTENSA_UNDEFINED;
4055
4056 if (ibuff == NULL)
43cd72b9
BW		 4057 {
4058 ibuff = xtensa_insnbuf_alloc (isa);
4059 sbuff = xtensa_insnbuf_alloc (isa);
4060 }
4061
e0001a05 4062 /* Decode the instruction. */
43cd72b9
BW		 4063 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4064 sec->size - irel->r_offset);
4065 fmt = xtensa_format_decode (isa, ibuff);
4066 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4067 if (slot == XTENSA_UNDEFINED)
4068 return XTENSA_UNDEFINED;
4069 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4070 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
e0001a05
NC		 4071}
4072
4073
4074bfd_boolean
7fa3d080
BW		 4075is_l32r_relocation (bfd *abfd,
4076 asection *sec,
4077 bfd_byte *contents,
4078 Elf_Internal_Rela *irel)
e0001a05
NC		 4079{
4080 xtensa_opcode opcode;
43cd72b9 4081 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
e0001a05 4082 return FALSE;
43cd72b9 4083 opcode = get_relocation_opcode (abfd, sec, contents, irel);
e0001a05
NC		 4084 return (opcode == get_l32r_opcode ());
4085}
4086
e0001a05 4087
43cd72b9 4088static bfd_size_type
7fa3d080
BW		 4089get_asm_simplify_size (bfd_byte *contents,
4090 bfd_size_type content_len,
4091 bfd_size_type offset)
e0001a05 4092{
43cd72b9 4093 bfd_size_type insnlen, size = 0;
e0001a05 4094
43cd72b9
BW		 4095 /* Decode the size of the next two instructions. */
4096 insnlen = insn_decode_len (contents, content_len, offset);
4097 if (insnlen == 0)
4098 return 0;
e0001a05 4099
43cd72b9 4100 size += insnlen;
68ffbac6 4101
43cd72b9
BW		 4102 insnlen = insn_decode_len (contents, content_len, offset + size);
4103 if (insnlen == 0)
4104 return 0;
e0001a05 4105
43cd72b9
BW		 4106 size += insnlen;
4107 return size;
4108}
e0001a05 4109
43cd72b9
BW		 4110
4111bfd_boolean
7fa3d080 4112is_alt_relocation (int r_type)
43cd72b9
BW		 4113{
4114 return (r_type >= R_XTENSA_SLOT0_ALT
4115 && r_type <= R_XTENSA_SLOT14_ALT);
e0001a05
NC		 4116}
4117
4118
43cd72b9 4119bfd_boolean
7fa3d080 4120is_operand_relocation (int r_type)
e0001a05 4121{
43cd72b9
BW		 4122 switch (r_type)
4123 {
4124 case R_XTENSA_OP0:
4125 case R_XTENSA_OP1:
4126 case R_XTENSA_OP2:
4127 return TRUE;
e0001a05 4128
43cd72b9
BW		 4129 default:
4130 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4131 return TRUE;
4132 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4133 return TRUE;
4134 break;
4135 }
e0001a05 4136
43cd72b9 4137 return FALSE;
e0001a05
NC		 4138}
4139
68ffbac6 4140
43cd72b9 4141#define MIN_INSN_LENGTH 2
e0001a05 4142
43cd72b9
BW		 4143/* Return 0 if it fails to decode. */
4144
4145bfd_size_type
7fa3d080
BW		 4146insn_decode_len (bfd_byte *contents,
4147 bfd_size_type content_len,
4148 bfd_size_type offset)
e0001a05 4149{
43cd72b9
BW		 4150 int insn_len;
4151 xtensa_isa isa = xtensa_default_isa;
4152 xtensa_format fmt;
4153 static xtensa_insnbuf ibuff = NULL;
e0001a05 4154
43cd72b9
BW		 4155 if (offset + MIN_INSN_LENGTH > content_len)
4156 return 0;
e0001a05 4157
43cd72b9
BW		 4158 if (ibuff == NULL)
4159 ibuff = xtensa_insnbuf_alloc (isa);
4160 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4161 content_len - offset);
4162 fmt = xtensa_format_decode (isa, ibuff);
4163 if (fmt == XTENSA_UNDEFINED)
4164 return 0;
4165 insn_len = xtensa_format_length (isa, fmt);
4166 if (insn_len == XTENSA_UNDEFINED)
4167 return 0;
4168 return insn_len;
e0001a05
NC		 4169}
4170
4171
43cd72b9
BW		 4172/* Decode the opcode for a single slot instruction.
4173 Return 0 if it fails to decode or the instruction is multi-slot. */
e0001a05 4174
43cd72b9 4175xtensa_opcode
7fa3d080
BW		 4176insn_decode_opcode (bfd_byte *contents,
4177 bfd_size_type content_len,
4178 bfd_size_type offset,
4179 int slot)
e0001a05 4180{
e0001a05 4181 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 4182 xtensa_format fmt;
4183 static xtensa_insnbuf insnbuf = NULL;
4184 static xtensa_insnbuf slotbuf = NULL;
4185
4186 if (offset + MIN_INSN_LENGTH > content_len)
e0001a05
NC		 4187 return XTENSA_UNDEFINED;
4188
4189 if (insnbuf == NULL)
43cd72b9
BW		 4190 {
4191 insnbuf = xtensa_insnbuf_alloc (isa);
4192 slotbuf = xtensa_insnbuf_alloc (isa);
4193 }
4194
4195 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4196 content_len - offset);
4197 fmt = xtensa_format_decode (isa, insnbuf);
4198 if (fmt == XTENSA_UNDEFINED)
e0001a05 4199 return XTENSA_UNDEFINED;
43cd72b9
BW		 4200
4201 if (slot >= xtensa_format_num_slots (isa, fmt))
e0001a05 4202 return XTENSA_UNDEFINED;
e0001a05 4203
43cd72b9
BW		 4204 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4205 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4206}
e0001a05 4207
e0001a05 4208
43cd72b9
BW		 4209/* The offset is the offset in the contents.
4210 The address is the address of that offset. */
e0001a05 4211
43cd72b9 4212static bfd_boolean
7fa3d080
BW		 4213check_branch_target_aligned (bfd_byte *contents,
4214 bfd_size_type content_length,
4215 bfd_vma offset,
4216 bfd_vma address)
43cd72b9
BW		 4217{
4218 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4219 if (insn_len == 0)
4220 return FALSE;
4221 return check_branch_target_aligned_address (address, insn_len);
4222}
e0001a05 4223
e0001a05 4224
43cd72b9 4225static bfd_boolean
7fa3d080
BW		 4226check_loop_aligned (bfd_byte *contents,
4227 bfd_size_type content_length,
4228 bfd_vma offset,
4229 bfd_vma address)
e0001a05 4230{
43cd72b9 4231 bfd_size_type loop_len, insn_len;
64b607e6 4232 xtensa_opcode opcode;
e0001a05 4233
64b607e6
BW		 4234 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4235 if (opcode == XTENSA_UNDEFINED
4236 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4237 {
4238 BFD_ASSERT (FALSE);
4239 return FALSE;
4240 }
68ffbac6 4241
43cd72b9 4242 loop_len = insn_decode_len (contents, content_length, offset);
43cd72b9 4243 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
64b607e6
BW		 4244 if (loop_len == 0 || insn_len == 0)
4245 {
4246 BFD_ASSERT (FALSE);
4247 return FALSE;
4248 }
e0001a05 4249
43cd72b9
BW		 4250 return check_branch_target_aligned_address (address + loop_len, insn_len);
4251}
e0001a05 4252
e0001a05
NC		 4253
4254static bfd_boolean
7fa3d080 4255check_branch_target_aligned_address (bfd_vma addr, int len)
e0001a05 4256{
43cd72b9
BW		 4257 if (len == 8)
4258 return (addr % 8 == 0);
4259 return ((addr >> 2) == ((addr + len - 1) >> 2));
e0001a05
NC		 4260}
4261
43cd72b9
BW		 4262\f
4263/* Instruction widening and narrowing. */
e0001a05 4264
7fa3d080
BW		 4265/* When FLIX is available we need to access certain instructions only
4266 when they are 16-bit or 24-bit instructions. This table caches
4267 information about such instructions by walking through all the
4268 opcodes and finding the smallest single-slot format into which each
4269 can be encoded. */
4270
4271static xtensa_format *op_single_fmt_table = NULL;
e0001a05
NC		 4272
4273
7fa3d080
BW		 4274static void
4275init_op_single_format_table (void)
e0001a05 4276{
7fa3d080
BW		 4277 xtensa_isa isa = xtensa_default_isa;
4278 xtensa_insnbuf ibuf;
4279 xtensa_opcode opcode;
4280 xtensa_format fmt;
4281 int num_opcodes;
4282
4283 if (op_single_fmt_table)
4284 return;
4285
4286 ibuf = xtensa_insnbuf_alloc (isa);
4287 num_opcodes = xtensa_isa_num_opcodes (isa);
4288
4289 op_single_fmt_table = (xtensa_format *)
4290 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4291 for (opcode = 0; opcode < num_opcodes; opcode++)
4292 {
4293 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4294 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4295 {
4296 if (xtensa_format_num_slots (isa, fmt) == 1
4297 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4298 {
4299 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4300 int fmt_length = xtensa_format_length (isa, fmt);
4301 if (old_fmt == XTENSA_UNDEFINED
4302 || fmt_length < xtensa_format_length (isa, old_fmt))
4303 op_single_fmt_table[opcode] = fmt;
4304 }
4305 }
4306 }
4307 xtensa_insnbuf_free (isa, ibuf);
4308}
4309
4310
4311static xtensa_format
4312get_single_format (xtensa_opcode opcode)
4313{
4314 init_op_single_format_table ();
4315 return op_single_fmt_table[opcode];
4316}
e0001a05 4317
e0001a05 4318
43cd72b9
BW		 4319/* For the set of narrowable instructions we do NOT include the
4320 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4321 involved during linker relaxation that may require these to
4322 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4323 requires special case code to ensure it only works when op1 == op2. */
e0001a05 4324
7fa3d080
BW		 4325struct string_pair
4326{
4327 const char *wide;
4328 const char *narrow;
4329};
4330
43cd72b9 4331struct string_pair narrowable[] =
e0001a05 4332{
43cd72b9
BW		 4333 { "add", "add.n" },
4334 { "addi", "addi.n" },
4335 { "addmi", "addi.n" },
4336 { "l32i", "l32i.n" },
4337 { "movi", "movi.n" },
4338 { "ret", "ret.n" },
4339 { "retw", "retw.n" },
4340 { "s32i", "s32i.n" },
4341 { "or", "mov.n" } /* special case only when op1 == op2 */
4342};
e0001a05 4343
43cd72b9 4344struct string_pair widenable[] =
e0001a05 4345{
43cd72b9
BW		 4346 { "add", "add.n" },
4347 { "addi", "addi.n" },
4348 { "addmi", "addi.n" },
4349 { "beqz", "beqz.n" },
4350 { "bnez", "bnez.n" },
4351 { "l32i", "l32i.n" },
4352 { "movi", "movi.n" },
4353 { "ret", "ret.n" },
4354 { "retw", "retw.n" },
4355 { "s32i", "s32i.n" },
4356 { "or", "mov.n" } /* special case only when op1 == op2 */
4357};
e0001a05
NC		 4358
4359
64b607e6
BW		 4360/* Check if an instruction can be "narrowed", i.e., changed from a standard
4361 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4362 return the instruction buffer holding the narrow instruction. Otherwise,
4363 return 0. The set of valid narrowing are specified by a string table
43cd72b9
BW		 4364 but require some special case operand checks in some cases. */
4365
64b607e6
BW		 4366static xtensa_insnbuf
4367can_narrow_instruction (xtensa_insnbuf slotbuf,
4368 xtensa_format fmt,
4369 xtensa_opcode opcode)
e0001a05 4370{
43cd72b9 4371 xtensa_isa isa = xtensa_default_isa;
64b607e6
BW		 4372 xtensa_format o_fmt;
4373 unsigned opi;
e0001a05 4374
43cd72b9
BW		 4375 static xtensa_insnbuf o_insnbuf = NULL;
4376 static xtensa_insnbuf o_slotbuf = NULL;
e0001a05 4377
64b607e6 4378 if (o_insnbuf == NULL)
43cd72b9 4379 {
43cd72b9
BW		 4380 o_insnbuf = xtensa_insnbuf_alloc (isa);
4381 o_slotbuf = xtensa_insnbuf_alloc (isa);
4382 }
e0001a05 4383
64b607e6 4384 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
43cd72b9
BW		 4385 {
4386 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
e0001a05 4387
43cd72b9
BW		 4388 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4389 {
4390 uint32 value, newval;
4391 int i, operand_count, o_operand_count;
4392 xtensa_opcode o_opcode;
e0001a05 4393
43cd72b9
BW		 4394 /* Address does not matter in this case. We might need to
4395 fix it to handle branches/jumps. */
4396 bfd_vma self_address = 0;
e0001a05 4397
43cd72b9
BW		 4398 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4399 if (o_opcode == XTENSA_UNDEFINED)
64b607e6 4400 return 0;
43cd72b9
BW		 4401 o_fmt = get_single_format (o_opcode);
4402 if (o_fmt == XTENSA_UNDEFINED)
64b607e6 4403 return 0;
e0001a05 4404
43cd72b9
BW		 4405 if (xtensa_format_length (isa, fmt) != 3
4406 || xtensa_format_length (isa, o_fmt) != 2)
64b607e6 4407 return 0;
e0001a05 4408
43cd72b9
BW		 4409 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4410 operand_count = xtensa_opcode_num_operands (isa, opcode);
4411 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
e0001a05 4412
43cd72b9 4413 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
64b607e6 4414 return 0;
e0001a05 4415
43cd72b9
BW		 4416 if (!is_or)
4417 {
4418 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
64b607e6 4419 return 0;
43cd72b9
BW		 4420 }
4421 else
4422 {
4423 uint32 rawval0, rawval1, rawval2;
e0001a05 4424
64b607e6
BW		 4425 if (o_operand_count + 1 != operand_count
4426 || xtensa_operand_get_field (isa, opcode, 0,
4427 fmt, 0, slotbuf, &rawval0) != 0
4428 || xtensa_operand_get_field (isa, opcode, 1,
4429 fmt, 0, slotbuf, &rawval1) != 0
4430 || xtensa_operand_get_field (isa, opcode, 2,
4431 fmt, 0, slotbuf, &rawval2) != 0
4432 || rawval1 != rawval2
4433 || rawval0 == rawval1 /* it is a nop */)
4434 return 0;
43cd72b9 4435 }
e0001a05 4436
43cd72b9
BW		 4437 for (i = 0; i < o_operand_count; ++i)
4438 {
4439 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4440 slotbuf, &value)
4441 || xtensa_operand_decode (isa, opcode, i, &value))
64b607e6 4442 return 0;
e0001a05 4443
43cd72b9
BW		 4444 /* PC-relative branches need adjustment, but
4445 the PC-rel operand will always have a relocation. */
4446 newval = value;
4447 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4448 self_address)
4449 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4450 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4451 o_slotbuf, newval))
64b607e6 4452 return 0;
43cd72b9 4453 }
e0001a05 4454
64b607e6
BW		 4455 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4456 return 0;
e0001a05 4457
64b607e6 4458 return o_insnbuf;
43cd72b9
BW		 4459 }
4460 }
64b607e6 4461 return 0;
43cd72b9 4462}
e0001a05 4463
e0001a05 4464
64b607e6
BW		 4465/* Attempt to narrow an instruction. If the narrowing is valid, perform
4466 the action in-place directly into the contents and return TRUE. Otherwise,
4467 the return value is FALSE and the contents are not modified. */
e0001a05 4468
43cd72b9 4469static bfd_boolean
64b607e6
BW		 4470narrow_instruction (bfd_byte *contents,
4471 bfd_size_type content_length,
4472 bfd_size_type offset)
e0001a05 4473{
43cd72b9 4474 xtensa_opcode opcode;
64b607e6 4475 bfd_size_type insn_len;
43cd72b9 4476 xtensa_isa isa = xtensa_default_isa;
64b607e6
BW		 4477 xtensa_format fmt;
4478 xtensa_insnbuf o_insnbuf;
e0001a05 4479
43cd72b9
BW		 4480 static xtensa_insnbuf insnbuf = NULL;
4481 static xtensa_insnbuf slotbuf = NULL;
e0001a05 4482
43cd72b9
BW		 4483 if (insnbuf == NULL)
4484 {
4485 insnbuf = xtensa_insnbuf_alloc (isa);
4486 slotbuf = xtensa_insnbuf_alloc (isa);
43cd72b9 4487 }
e0001a05 4488
43cd72b9 4489 BFD_ASSERT (offset < content_length);
2c8c90bc 4490
43cd72b9 4491 if (content_length < 2)
e0001a05
NC		 4492 return FALSE;
4493
64b607e6 4494 /* We will hand-code a few of these for a little while.
43cd72b9
BW		 4495 These have all been specified in the assembler aleady. */
4496 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4497 content_length - offset);
4498 fmt = xtensa_format_decode (isa, insnbuf);
4499 if (xtensa_format_num_slots (isa, fmt) != 1)
e0001a05
NC		 4500 return FALSE;
4501
43cd72b9 4502 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
e0001a05
NC		 4503 return FALSE;
4504
43cd72b9
BW		 4505 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4506 if (opcode == XTENSA_UNDEFINED)
e0001a05 4507 return FALSE;
43cd72b9
BW		 4508 insn_len = xtensa_format_length (isa, fmt);
4509 if (insn_len > content_length)
4510 return FALSE;
4511
64b607e6
BW		 4512 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4513 if (o_insnbuf)
4514 {
4515 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4516 content_length - offset);
4517 return TRUE;
4518 }
4519
4520 return FALSE;
4521}
4522
4523
4524/* Check if an instruction can be "widened", i.e., changed from a 2-byte
4525 "density" instruction to a standard 3-byte instruction. If it is valid,
4526 return the instruction buffer holding the wide instruction. Otherwise,
4527 return 0. The set of valid widenings are specified by a string table
4528 but require some special case operand checks in some cases. */
4529
4530static xtensa_insnbuf
4531can_widen_instruction (xtensa_insnbuf slotbuf,
4532 xtensa_format fmt,
4533 xtensa_opcode opcode)
4534{
4535 xtensa_isa isa = xtensa_default_isa;
4536 xtensa_format o_fmt;
4537 unsigned opi;
4538
4539 static xtensa_insnbuf o_insnbuf = NULL;
4540 static xtensa_insnbuf o_slotbuf = NULL;
4541
4542 if (o_insnbuf == NULL)
4543 {
4544 o_insnbuf = xtensa_insnbuf_alloc (isa);
4545 o_slotbuf = xtensa_insnbuf_alloc (isa);
4546 }
4547
4548 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
e0001a05 4549 {
43cd72b9
BW		 4550 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4551 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4552 || strcmp ("bnez", widenable[opi].wide) == 0);
e0001a05 4553
43cd72b9
BW		 4554 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4555 {
4556 uint32 value, newval;
4557 int i, operand_count, o_operand_count, check_operand_count;
4558 xtensa_opcode o_opcode;
e0001a05 4559
43cd72b9
BW		 4560 /* Address does not matter in this case. We might need to fix it
4561 to handle branches/jumps. */
4562 bfd_vma self_address = 0;
e0001a05 4563
43cd72b9
BW		 4564 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4565 if (o_opcode == XTENSA_UNDEFINED)
64b607e6 4566 return 0;
43cd72b9
BW		 4567 o_fmt = get_single_format (o_opcode);
4568 if (o_fmt == XTENSA_UNDEFINED)
64b607e6 4569 return 0;
e0001a05 4570
43cd72b9
BW		 4571 if (xtensa_format_length (isa, fmt) != 2
4572 || xtensa_format_length (isa, o_fmt) != 3)
64b607e6 4573 return 0;
e0001a05 4574
43cd72b9
BW		 4575 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4576 operand_count = xtensa_opcode_num_operands (isa, opcode);
4577 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4578 check_operand_count = o_operand_count;
e0001a05 4579
43cd72b9 4580 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
64b607e6 4581 return 0;
e0001a05 4582
43cd72b9
BW		 4583 if (!is_or)
4584 {
4585 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
64b607e6 4586 return 0;
43cd72b9
BW		 4587 }
4588 else
4589 {
4590 uint32 rawval0, rawval1;
4591
64b607e6
BW		 4592 if (o_operand_count != operand_count + 1
4593 || xtensa_operand_get_field (isa, opcode, 0,
4594 fmt, 0, slotbuf, &rawval0) != 0
4595 || xtensa_operand_get_field (isa, opcode, 1,
4596 fmt, 0, slotbuf, &rawval1) != 0
4597 || rawval0 == rawval1 /* it is a nop */)
4598 return 0;
43cd72b9
BW		 4599 }
4600 if (is_branch)
4601 check_operand_count--;
4602
64b607e6 4603 for (i = 0; i < check_operand_count; i++)
43cd72b9
BW		 4604 {
4605 int new_i = i;
4606 if (is_or && i == o_operand_count - 1)
4607 new_i = i - 1;
4608 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4609 slotbuf, &value)
4610 || xtensa_operand_decode (isa, opcode, new_i, &value))
64b607e6 4611 return 0;
43cd72b9
BW		 4612
4613 /* PC-relative branches need adjustment, but
4614 the PC-rel operand will always have a relocation. */
4615 newval = value;
4616 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4617 self_address)
4618 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4619 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4620 o_slotbuf, newval))
64b607e6 4621 return 0;
43cd72b9
BW		 4622 }
4623
4624 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
64b607e6 4625 return 0;
43cd72b9 4626
64b607e6 4627 return o_insnbuf;
43cd72b9
BW		 4628 }
4629 }
64b607e6
BW		 4630 return 0;
4631}
4632
68ffbac6 4633
64b607e6
BW		 4634/* Attempt to widen an instruction. If the widening is valid, perform
4635 the action in-place directly into the contents and return TRUE. Otherwise,
4636 the return value is FALSE and the contents are not modified. */
4637
4638static bfd_boolean
4639widen_instruction (bfd_byte *contents,
4640 bfd_size_type content_length,
4641 bfd_size_type offset)
4642{
4643 xtensa_opcode opcode;
4644 bfd_size_type insn_len;
4645 xtensa_isa isa = xtensa_default_isa;
4646 xtensa_format fmt;
4647 xtensa_insnbuf o_insnbuf;
4648
4649 static xtensa_insnbuf insnbuf = NULL;
4650 static xtensa_insnbuf slotbuf = NULL;
4651
4652 if (insnbuf == NULL)
4653 {
4654 insnbuf = xtensa_insnbuf_alloc (isa);
4655 slotbuf = xtensa_insnbuf_alloc (isa);
4656 }
4657
4658 BFD_ASSERT (offset < content_length);
4659
4660 if (content_length < 2)
4661 return FALSE;
4662
4663 /* We will hand-code a few of these for a little while.
4664 These have all been specified in the assembler aleady. */
4665 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4666 content_length - offset);
4667 fmt = xtensa_format_decode (isa, insnbuf);
4668 if (xtensa_format_num_slots (isa, fmt) != 1)
4669 return FALSE;
4670
4671 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4672 return FALSE;
4673
4674 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4675 if (opcode == XTENSA_UNDEFINED)
4676 return FALSE;
4677 insn_len = xtensa_format_length (isa, fmt);
4678 if (insn_len > content_length)
4679 return FALSE;
4680
4681 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4682 if (o_insnbuf)
4683 {
4684 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4685 content_length - offset);
4686 return TRUE;
4687 }
43cd72b9 4688 return FALSE;
e0001a05
NC		 4689}
4690
43cd72b9
BW		 4691\f
4692/* Code for transforming CALLs at link-time. */
e0001a05 4693
43cd72b9 4694static bfd_reloc_status_type
7fa3d080
BW		 4695elf_xtensa_do_asm_simplify (bfd_byte *contents,
4696 bfd_vma address,
4697 bfd_vma content_length,
4698 char **error_message)
e0001a05 4699{
43cd72b9
BW		 4700 static xtensa_insnbuf insnbuf = NULL;
4701 static xtensa_insnbuf slotbuf = NULL;
4702 xtensa_format core_format = XTENSA_UNDEFINED;
4703 xtensa_opcode opcode;
4704 xtensa_opcode direct_call_opcode;
4705 xtensa_isa isa = xtensa_default_isa;
4706 bfd_byte *chbuf = contents + address;
4707 int opn;
e0001a05 4708
43cd72b9 4709 if (insnbuf == NULL)
e0001a05 4710 {
43cd72b9
BW		 4711 insnbuf = xtensa_insnbuf_alloc (isa);
4712 slotbuf = xtensa_insnbuf_alloc (isa);
e0001a05 4713 }
e0001a05 4714
43cd72b9
BW		 4715 if (content_length < address)
4716 {
4717 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4718 return bfd_reloc_other;
4719 }
e0001a05 4720
43cd72b9
BW		 4721 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4722 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4723 if (direct_call_opcode == XTENSA_UNDEFINED)
4724 {
4725 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4726 return bfd_reloc_other;
4727 }
68ffbac6 4728
43cd72b9
BW		 4729 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4730 core_format = xtensa_format_lookup (isa, "x24");
4731 opcode = xtensa_opcode_lookup (isa, "or");
4732 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
68ffbac6 4733 for (opn = 0; opn < 3; opn++)
43cd72b9
BW		 4734 {
4735 uint32 regno = 1;
4736 xtensa_operand_encode (isa, opcode, opn, &regno);
4737 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4738 slotbuf, regno);
4739 }
4740 xtensa_format_encode (isa, core_format, insnbuf);
4741 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4742 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
e0001a05 4743
43cd72b9
BW		 4744 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4745 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4746 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
e0001a05 4747
43cd72b9
BW		 4748 xtensa_format_encode (isa, core_format, insnbuf);
4749 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4750 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4751 content_length - address - 3);
e0001a05 4752
43cd72b9
BW		 4753 return bfd_reloc_ok;
4754}
e0001a05 4755
e0001a05 4756
43cd72b9 4757static bfd_reloc_status_type
7fa3d080
BW		 4758contract_asm_expansion (bfd_byte *contents,
4759 bfd_vma content_length,
4760 Elf_Internal_Rela *irel,
4761 char **error_message)
43cd72b9
BW		 4762{
4763 bfd_reloc_status_type retval =
4764 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4765 error_message);
e0001a05 4766
43cd72b9
BW		 4767 if (retval != bfd_reloc_ok)
4768 return bfd_reloc_dangerous;
e0001a05 4769
43cd72b9
BW		 4770 /* Update the irel->r_offset field so that the right immediate and
4771 the right instruction are modified during the relocation. */
4772 irel->r_offset += 3;
4773 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4774 return bfd_reloc_ok;
4775}
e0001a05 4776
e0001a05 4777
43cd72b9 4778static xtensa_opcode
7fa3d080 4779swap_callx_for_call_opcode (xtensa_opcode opcode)
e0001a05 4780{
43cd72b9 4781 init_call_opcodes ();
e0001a05 4782
43cd72b9
BW		 4783 if (opcode == callx0_op) return call0_op;
4784 if (opcode == callx4_op) return call4_op;
4785 if (opcode == callx8_op) return call8_op;
4786 if (opcode == callx12_op) return call12_op;
e0001a05 4787
43cd72b9
BW		 4788 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4789 return XTENSA_UNDEFINED;
4790}
e0001a05 4791
e0001a05 4792
43cd72b9
BW		 4793/* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4794 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4795 If not, return XTENSA_UNDEFINED. */
e0001a05 4796
43cd72b9
BW		 4797#define L32R_TARGET_REG_OPERAND 0
4798#define CONST16_TARGET_REG_OPERAND 0
4799#define CALLN_SOURCE_OPERAND 0
e0001a05 4800
68ffbac6 4801static xtensa_opcode
7fa3d080 4802get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
e0001a05 4803{
43cd72b9
BW		 4804 static xtensa_insnbuf insnbuf = NULL;
4805 static xtensa_insnbuf slotbuf = NULL;
4806 xtensa_format fmt;
4807 xtensa_opcode opcode;
4808 xtensa_isa isa = xtensa_default_isa;
4809 uint32 regno, const16_regno, call_regno;
4810 int offset = 0;
e0001a05 4811
43cd72b9 4812 if (insnbuf == NULL)
e0001a05 4813 {
43cd72b9
BW		 4814 insnbuf = xtensa_insnbuf_alloc (isa);
4815 slotbuf = xtensa_insnbuf_alloc (isa);
e0001a05 4816 }
43cd72b9
BW		 4817
4818 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4819 fmt = xtensa_format_decode (isa, insnbuf);
4820 if (fmt == XTENSA_UNDEFINED
4821 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4822 return XTENSA_UNDEFINED;
4823
4824 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4825 if (opcode == XTENSA_UNDEFINED)
4826 return XTENSA_UNDEFINED;
4827
4828 if (opcode == get_l32r_opcode ())
e0001a05 4829 {
43cd72b9
BW		 4830 if (p_uses_l32r)
4831 *p_uses_l32r = TRUE;
4832 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4833 fmt, 0, slotbuf, &regno)
4834 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4835 &regno))
4836 return XTENSA_UNDEFINED;
e0001a05 4837 }
43cd72b9 4838 else if (opcode == get_const16_opcode ())
e0001a05 4839 {
43cd72b9
BW		 4840 if (p_uses_l32r)
4841 *p_uses_l32r = FALSE;
4842 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4843 fmt, 0, slotbuf, &regno)
4844 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4845 &regno))
4846 return XTENSA_UNDEFINED;
4847
4848 /* Check that the next instruction is also CONST16. */
4849 offset += xtensa_format_length (isa, fmt);
4850 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4851 fmt = xtensa_format_decode (isa, insnbuf);
4852 if (fmt == XTENSA_UNDEFINED
4853 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4854 return XTENSA_UNDEFINED;
4855 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4856 if (opcode != get_const16_opcode ())
4857 return XTENSA_UNDEFINED;
4858
4859 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4860 fmt, 0, slotbuf, &const16_regno)
4861 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4862 &const16_regno)
4863 || const16_regno != regno)
4864 return XTENSA_UNDEFINED;
e0001a05 4865 }
43cd72b9
BW		 4866 else
4867 return XTENSA_UNDEFINED;
e0001a05 4868
43cd72b9
BW		 4869 /* Next instruction should be an CALLXn with operand 0 == regno. */
4870 offset += xtensa_format_length (isa, fmt);
4871 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4872 fmt = xtensa_format_decode (isa, insnbuf);
4873 if (fmt == XTENSA_UNDEFINED
4874 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4875 return XTENSA_UNDEFINED;
4876 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
68ffbac6 4877 if (opcode == XTENSA_UNDEFINED
43cd72b9
BW		 4878 || !is_indirect_call_opcode (opcode))
4879 return XTENSA_UNDEFINED;
e0001a05 4880
43cd72b9
BW		 4881 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4882 fmt, 0, slotbuf, &call_regno)
4883 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4884 &call_regno))
4885 return XTENSA_UNDEFINED;
e0001a05 4886
43cd72b9
BW		 4887 if (call_regno != regno)
4888 return XTENSA_UNDEFINED;
e0001a05 4889
43cd72b9
BW		 4890 return opcode;
4891}
e0001a05 4892
43cd72b9
BW		 4893\f
4894/* Data structures used during relaxation. */
e0001a05 4895
43cd72b9 4896/* r_reloc: relocation values. */
e0001a05 4897
43cd72b9
BW		 4898/* Through the relaxation process, we need to keep track of the values
4899 that will result from evaluating relocations. The standard ELF
4900 relocation structure is not sufficient for this purpose because we're
4901 operating on multiple input files at once, so we need to know which
4902 input file a relocation refers to. The r_reloc structure thus
4903 records both the input file (bfd) and ELF relocation.
e0001a05 4904
43cd72b9
BW		 4905 For efficiency, an r_reloc also contains a "target_offset" field to
4906 cache the target-section-relative offset value that is represented by
4907 the relocation.
68ffbac6 4908
43cd72b9
BW		 4909 The r_reloc also contains a virtual offset that allows multiple
4910 inserted literals to be placed at the same "address" with
4911 different offsets. */
e0001a05 4912
43cd72b9 4913typedef struct r_reloc_struct r_reloc;
e0001a05 4914
43cd72b9 4915struct r_reloc_struct
e0001a05 4916{
43cd72b9
BW		 4917 bfd *abfd;
4918 Elf_Internal_Rela rela;
e0001a05 4919 bfd_vma target_offset;
43cd72b9 4920 bfd_vma virtual_offset;
e0001a05
NC		 4921};
4922
e0001a05 4923
43cd72b9
BW		 4924/* The r_reloc structure is included by value in literal_value, but not
4925 every literal_value has an associated relocation -- some are simple
4926 constants. In such cases, we set all the fields in the r_reloc
4927 struct to zero. The r_reloc_is_const function should be used to
4928 detect this case. */
e0001a05 4929
43cd72b9 4930static bfd_boolean
7fa3d080 4931r_reloc_is_const (const r_reloc *r_rel)
e0001a05 4932{
43cd72b9 4933 return (r_rel->abfd == NULL);
e0001a05
NC		 4934}
4935
4936
43cd72b9 4937static bfd_vma
7fa3d080 4938r_reloc_get_target_offset (const r_reloc *r_rel)
e0001a05 4939{
43cd72b9
BW		 4940 bfd_vma target_offset;
4941 unsigned long r_symndx;
e0001a05 4942
43cd72b9
BW		 4943 BFD_ASSERT (!r_reloc_is_const (r_rel));
4944 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4945 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4946 return (target_offset + r_rel->rela.r_addend);
4947}
e0001a05 4948
e0001a05 4949
43cd72b9 4950static struct elf_link_hash_entry *
7fa3d080 4951r_reloc_get_hash_entry (const r_reloc *r_rel)
e0001a05 4952{
43cd72b9
BW		 4953 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4954 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4955}
e0001a05 4956
43cd72b9
BW		 4957
4958static asection *
7fa3d080 4959r_reloc_get_section (const r_reloc *r_rel)
43cd72b9
BW		 4960{
4961 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4962 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4963}
e0001a05
NC		 4964
4965
4966static bfd_boolean
7fa3d080 4967r_reloc_is_defined (const r_reloc *r_rel)
e0001a05 4968{
43cd72b9
BW		 4969 asection *sec;
4970 if (r_rel == NULL)
e0001a05 4971 return FALSE;
e0001a05 4972
43cd72b9
BW		 4973 sec = r_reloc_get_section (r_rel);
4974 if (sec == bfd_abs_section_ptr
4975 || sec == bfd_com_section_ptr
4976 || sec == bfd_und_section_ptr)
4977 return FALSE;
4978 return TRUE;
e0001a05
NC		 4979}
4980
4981
7fa3d080
BW		 4982static void
4983r_reloc_init (r_reloc *r_rel,
4984 bfd *abfd,
4985 Elf_Internal_Rela *irel,
4986 bfd_byte *contents,
4987 bfd_size_type content_length)
4988{
4989 int r_type;
4990 reloc_howto_type *howto;
4991
4992 if (irel)
4993 {
4994 r_rel->rela = *irel;
4995 r_rel->abfd = abfd;
4996 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4997 r_rel->virtual_offset = 0;
4998 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4999 howto = &elf_howto_table[r_type];
5000 if (howto->partial_inplace)
5001 {
5002 bfd_vma inplace_val;
5003 BFD_ASSERT (r_rel->rela.r_offset < content_length);
5004
5005 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5006 r_rel->target_offset += inplace_val;
5007 }
5008 }
5009 else
5010 memset (r_rel, 0, sizeof (r_reloc));
5011}
5012
5013
43cd72b9
BW		 5014#if DEBUG
5015
e0001a05 5016static void
7fa3d080 5017print_r_reloc (FILE *fp, const r_reloc *r_rel)
e0001a05 5018{
43cd72b9
BW		 5019 if (r_reloc_is_defined (r_rel))
5020 {
5021 asection *sec = r_reloc_get_section (r_rel);
5022 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5023 }
5024 else if (r_reloc_get_hash_entry (r_rel))
5025 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5026 else
5027 fprintf (fp, " ?? + ");
e0001a05 5028
43cd72b9
BW		 5029 fprintf_vma (fp, r_rel->target_offset);
5030 if (r_rel->virtual_offset)
5031 {
5032 fprintf (fp, " + ");
5033 fprintf_vma (fp, r_rel->virtual_offset);
5034 }
68ffbac6 5035
43cd72b9
BW		 5036 fprintf (fp, ")");
5037}
e0001a05 5038
43cd72b9 5039#endif /* DEBUG */
e0001a05 5040
43cd72b9
BW		 5041\f
5042/* source_reloc: relocations that reference literals. */
e0001a05 5043
43cd72b9
BW		 5044/* To determine whether literals can be coalesced, we need to first
5045 record all the relocations that reference the literals. The
5046 source_reloc structure below is used for this purpose. The
5047 source_reloc entries are kept in a per-literal-section array, sorted
5048 by offset within the literal section (i.e., target offset).
e0001a05 5049
43cd72b9
BW		 5050 The source_sec and r_rel.rela.r_offset fields identify the source of
5051 the relocation. The r_rel field records the relocation value, i.e.,
5052 the offset of the literal being referenced. The opnd field is needed
5053 to determine the range of the immediate field to which the relocation
5054 applies, so we can determine whether another literal with the same
5055 value is within range. The is_null field is true when the relocation
5056 is being removed (e.g., when an L32R is being removed due to a CALLX
5057 that is converted to a direct CALL). */
e0001a05 5058
43cd72b9
BW		 5059typedef struct source_reloc_struct source_reloc;
5060
5061struct source_reloc_struct
e0001a05 5062{
43cd72b9
BW		 5063 asection *source_sec;
5064 r_reloc r_rel;
5065 xtensa_opcode opcode;
5066 int opnd;
5067 bfd_boolean is_null;
5068 bfd_boolean is_abs_literal;
5069};
e0001a05 5070
e0001a05 5071
e0001a05 5072static void
7fa3d080
BW		 5073init_source_reloc (source_reloc *reloc,
5074 asection *source_sec,
5075 const r_reloc *r_rel,
5076 xtensa_opcode opcode,
5077 int opnd,
5078 bfd_boolean is_abs_literal)
e0001a05 5079{
43cd72b9
BW		 5080 reloc->source_sec = source_sec;
5081 reloc->r_rel = *r_rel;
5082 reloc->opcode = opcode;
5083 reloc->opnd = opnd;
5084 reloc->is_null = FALSE;
5085 reloc->is_abs_literal = is_abs_literal;
e0001a05
NC		 5086}
5087
e0001a05 5088
43cd72b9
BW		 5089/* Find the source_reloc for a particular source offset and relocation
5090 type. Note that the array is sorted by _target_ offset, so this is
5091 just a linear search. */
e0001a05 5092
43cd72b9 5093static source_reloc *
7fa3d080
BW		 5094find_source_reloc (source_reloc *src_relocs,
5095 int src_count,
5096 asection *sec,
5097 Elf_Internal_Rela *irel)
e0001a05 5098{
43cd72b9 5099 int i;
e0001a05 5100
43cd72b9
BW		 5101 for (i = 0; i < src_count; i++)
5102 {
5103 if (src_relocs[i].source_sec == sec
5104 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5105 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5106 == ELF32_R_TYPE (irel->r_info)))
5107 return &src_relocs[i];
5108 }
e0001a05 5109
43cd72b9 5110 return NULL;
e0001a05
NC		 5111}
5112
5113
43cd72b9 5114static int
7fa3d080 5115source_reloc_compare (const void *ap, const void *bp)
e0001a05 5116{
43cd72b9
BW		 5117 const source_reloc *a = (const source_reloc *) ap;
5118 const source_reloc *b = (const source_reloc *) bp;
e0001a05 5119
43cd72b9
BW		 5120 if (a->r_rel.target_offset != b->r_rel.target_offset)
5121 return (a->r_rel.target_offset - b->r_rel.target_offset);
e0001a05 5122
43cd72b9
BW		 5123 /* We don't need to sort on these criteria for correctness,
5124 but enforcing a more strict ordering prevents unstable qsort
5125 from behaving differently with different implementations.
5126 Without the code below we get correct but different results
5127 on Solaris 2.7 and 2.8. We would like to always produce the
5128 same results no matter the host. */
5129
5130 if ((!a->is_null) - (!b->is_null))
5131 return ((!a->is_null) - (!b->is_null));
5132 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
e0001a05
NC		 5133}
5134
43cd72b9
BW		 5135\f
5136/* Literal values and value hash tables. */
e0001a05 5137
43cd72b9
BW		 5138/* Literals with the same value can be coalesced. The literal_value
5139 structure records the value of a literal: the "r_rel" field holds the
5140 information from the relocation on the literal (if there is one) and
5141 the "value" field holds the contents of the literal word itself.
e0001a05 5142
43cd72b9
BW		 5143 The value_map structure records a literal value along with the
5144 location of a literal holding that value. The value_map hash table
5145 is indexed by the literal value, so that we can quickly check if a
5146 particular literal value has been seen before and is thus a candidate
5147 for coalescing. */
e0001a05 5148
43cd72b9
BW		 5149typedef struct literal_value_struct literal_value;
5150typedef struct value_map_struct value_map;
5151typedef struct value_map_hash_table_struct value_map_hash_table;
e0001a05 5152
43cd72b9 5153struct literal_value_struct
e0001a05 5154{
68ffbac6 5155 r_reloc r_rel;
43cd72b9
BW		 5156 unsigned long value;
5157 bfd_boolean is_abs_literal;
5158};
5159
5160struct value_map_struct
5161{
5162 literal_value val; /* The literal value. */
5163 r_reloc loc; /* Location of the literal. */
5164 value_map *next;
5165};
5166
5167struct value_map_hash_table_struct
5168{
5169 unsigned bucket_count;
5170 value_map **buckets;
5171 unsigned count;
5172 bfd_boolean has_last_loc;
5173 r_reloc last_loc;
5174};
5175
5176
e0001a05 5177static void
7fa3d080
BW		 5178init_literal_value (literal_value *lit,
5179 const r_reloc *r_rel,
5180 unsigned long value,
5181 bfd_boolean is_abs_literal)
e0001a05 5182{
43cd72b9
BW		 5183 lit->r_rel = *r_rel;
5184 lit->value = value;
5185 lit->is_abs_literal = is_abs_literal;
e0001a05
NC		 5186}
5187
5188
43cd72b9 5189static bfd_boolean
7fa3d080
BW		 5190literal_value_equal (const literal_value *src1,
5191 const literal_value *src2,
5192 bfd_boolean final_static_link)
e0001a05 5193{
43cd72b9 5194 struct elf_link_hash_entry *h1, *h2;
e0001a05 5195
68ffbac6 5196 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
43cd72b9 5197 return FALSE;
e0001a05 5198
43cd72b9
BW		 5199 if (r_reloc_is_const (&src1->r_rel))
5200 return (src1->value == src2->value);
e0001a05 5201
43cd72b9
BW		 5202 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5203 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5204 return FALSE;
e0001a05 5205
43cd72b9
BW		 5206 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5207 return FALSE;
68ffbac6 5208
43cd72b9
BW		 5209 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5210 return FALSE;
5211
5212 if (src1->value != src2->value)
5213 return FALSE;
68ffbac6 5214
43cd72b9
BW		 5215 /* Now check for the same section (if defined) or the same elf_hash
5216 (if undefined or weak). */
5217 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5218 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5219 if (r_reloc_is_defined (&src1->r_rel)
5220 && (final_static_link
5221 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5222 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5223 {
5224 if (r_reloc_get_section (&src1->r_rel)
5225 != r_reloc_get_section (&src2->r_rel))
5226 return FALSE;
5227 }
5228 else
5229 {
5230 /* Require that the hash entries (i.e., symbols) be identical. */
5231 if (h1 != h2 || h1 == 0)
5232 return FALSE;
5233 }
5234
5235 if (src1->is_abs_literal != src2->is_abs_literal)
5236 return FALSE;
5237
5238 return TRUE;
e0001a05
NC		 5239}
5240
e0001a05 5241
43cd72b9
BW		 5242/* Must be power of 2. */
5243#define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
e0001a05 5244
43cd72b9 5245static value_map_hash_table *
7fa3d080 5246value_map_hash_table_init (void)
43cd72b9
BW		 5247{
5248 value_map_hash_table *values;
e0001a05 5249
43cd72b9
BW		 5250 values = (value_map_hash_table *)
5251 bfd_zmalloc (sizeof (value_map_hash_table));
5252 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5253 values->count = 0;
5254 values->buckets = (value_map **)
5255 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
68ffbac6 5256 if (values->buckets == NULL)
43cd72b9
BW		 5257 {
5258 free (values);
5259 return NULL;
5260 }
5261 values->has_last_loc = FALSE;
5262
5263 return values;
5264}
5265
5266
5267static void
7fa3d080 5268value_map_hash_table_delete (value_map_hash_table *table)
e0001a05 5269{
43cd72b9
BW		 5270 free (table->buckets);
5271 free (table);
5272}
5273
5274
5275static unsigned
7fa3d080 5276hash_bfd_vma (bfd_vma val)
43cd72b9
BW		 5277{
5278 return (val >> 2) + (val >> 10);
5279}
5280
5281
5282static unsigned
7fa3d080 5283literal_value_hash (const literal_value *src)
43cd72b9
BW		 5284{
5285 unsigned hash_val;
e0001a05 5286
43cd72b9
BW		 5287 hash_val = hash_bfd_vma (src->value);
5288 if (!r_reloc_is_const (&src->r_rel))
e0001a05 5289 {
43cd72b9
BW		 5290 void *sec_or_hash;
5291
5292 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5293 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5294 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
68ffbac6 5295
43cd72b9
BW		 5296 /* Now check for the same section and the same elf_hash. */
5297 if (r_reloc_is_defined (&src->r_rel))
5298 sec_or_hash = r_reloc_get_section (&src->r_rel);
5299 else
5300 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
f60ca5e3 5301 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
e0001a05 5302 }
43cd72b9
BW		 5303 return hash_val;
5304}
e0001a05 5305
e0001a05 5306
43cd72b9 5307/* Check if the specified literal_value has been seen before. */
e0001a05 5308
43cd72b9 5309static value_map *
7fa3d080
BW		 5310value_map_get_cached_value (value_map_hash_table *map,
5311 const literal_value *val,
5312 bfd_boolean final_static_link)
43cd72b9
BW		 5313{
5314 value_map *map_e;
5315 value_map *bucket;
5316 unsigned idx;
5317
5318 idx = literal_value_hash (val);
5319 idx = idx & (map->bucket_count - 1);
5320 bucket = map->buckets[idx];
5321 for (map_e = bucket; map_e; map_e = map_e->next)
e0001a05 5322 {
43cd72b9
BW		 5323 if (literal_value_equal (&map_e->val, val, final_static_link))
5324 return map_e;
5325 }
5326 return NULL;
5327}
e0001a05 5328
e0001a05 5329
43cd72b9
BW		 5330/* Record a new literal value. It is illegal to call this if VALUE
5331 already has an entry here. */
5332
5333static value_map *
7fa3d080
BW		 5334add_value_map (value_map_hash_table *map,
5335 const literal_value *val,
5336 const r_reloc *loc,
5337 bfd_boolean final_static_link)
43cd72b9
BW		 5338{
5339 value_map **bucket_p;
5340 unsigned idx;
5341
5342 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5343 if (val_e == NULL)
5344 {
5345 bfd_set_error (bfd_error_no_memory);
5346 return NULL;
e0001a05
NC		 5347 }
5348
43cd72b9
BW		 5349 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5350 val_e->val = *val;
5351 val_e->loc = *loc;
5352
5353 idx = literal_value_hash (val);
5354 idx = idx & (map->bucket_count - 1);
5355 bucket_p = &map->buckets[idx];
5356
5357 val_e->next = *bucket_p;
5358 *bucket_p = val_e;
5359 map->count++;
5360 /* FIXME: Consider resizing the hash table if we get too many entries. */
68ffbac6 5361
43cd72b9 5362 return val_e;
e0001a05
NC		 5363}
5364
43cd72b9
BW		 5365\f
5366/* Lists of text actions (ta_) for narrowing, widening, longcall
5367 conversion, space fill, code & literal removal, etc. */
5368
5369/* The following text actions are generated:
5370
5371 "ta_remove_insn" remove an instruction or instructions
5372 "ta_remove_longcall" convert longcall to call
5373 "ta_convert_longcall" convert longcall to nop/call
5374 "ta_narrow_insn" narrow a wide instruction
5375 "ta_widen" widen a narrow instruction
5376 "ta_fill" add fill or remove fill
5377 removed < 0 is a fill; branches to the fill address will be
5378 changed to address + fill size (e.g., address - removed)
5379 removed >= 0 branches to the fill address will stay unchanged
5380 "ta_remove_literal" remove a literal; this action is
5381 indicated when a literal is removed
5382 or replaced.
5383 "ta_add_literal" insert a new literal; this action is
5384 indicated when a literal has been moved.
5385 It may use a virtual_offset because
5386 multiple literals can be placed at the
5387 same location.
5388
5389 For each of these text actions, we also record the number of bytes
5390 removed by performing the text action. In the case of a "ta_widen"
5391 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5392
5393typedef struct text_action_struct text_action;
5394typedef struct text_action_list_struct text_action_list;
5395typedef enum text_action_enum_t text_action_t;
5396
5397enum text_action_enum_t
5398{
5399 ta_none,
5400 ta_remove_insn, /* removed = -size */
5401 ta_remove_longcall, /* removed = -size */
5402 ta_convert_longcall, /* removed = 0 */
5403 ta_narrow_insn, /* removed = -1 */
5404 ta_widen_insn, /* removed = +1 */
5405 ta_fill, /* removed = +size */
5406 ta_remove_literal,
5407 ta_add_literal
5408};
e0001a05 5409
e0001a05 5410
43cd72b9
BW		 5411/* Structure for a text action record. */
5412struct text_action_struct
e0001a05 5413{
43cd72b9
BW		 5414 text_action_t action;
5415 asection *sec; /* Optional */
5416 bfd_vma offset;
5417 bfd_vma virtual_offset; /* Zero except for adding literals. */
5418 int removed_bytes;
5419 literal_value value; /* Only valid when adding literals. */
43cd72b9 5420};
e0001a05 5421
071aa5c9
MF		 5422struct removal_by_action_entry_struct
5423{
5424 bfd_vma offset;
5425 int removed;
5426 int eq_removed;
5427 int eq_removed_before_fill;
5428};
5429typedef struct removal_by_action_entry_struct removal_by_action_entry;
5430
5431struct removal_by_action_map_struct
5432{
5433 unsigned n_entries;
5434 removal_by_action_entry *entry;
5435};
5436typedef struct removal_by_action_map_struct removal_by_action_map;
5437
e0001a05 5438
43cd72b9
BW		 5439/* List of all of the actions taken on a text section. */
5440struct text_action_list_struct
5441{
4c2af04f
MF		 5442 unsigned count;
5443 splay_tree tree;
071aa5c9 5444 removal_by_action_map map;
43cd72b9 5445};
e0001a05 5446
e0001a05 5447
7fa3d080
BW		 5448static text_action *
5449find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
43cd72b9 5450{
4c2af04f 5451 text_action a;
43cd72b9
BW		 5452
5453 /* It is not necessary to fill at the end of a section. */
5454 if (sec->size == offset)
5455 return NULL;
5456
4c2af04f
MF		 5457 a.offset = offset;
5458 a.action = ta_fill;
5459
5460 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5461 if (node)
5462 return (text_action *)node->value;
43cd72b9
BW		 5463 return NULL;
5464}
5465
5466
5467static int
7fa3d080
BW		 5468compute_removed_action_diff (const text_action *ta,
5469 asection *sec,
5470 bfd_vma offset,
5471 int removed,
5472 int removable_space)
43cd72b9
BW		 5473{
5474 int new_removed;
5475 int current_removed = 0;
5476
7fa3d080 5477 if (ta)
43cd72b9
BW		 5478 current_removed = ta->removed_bytes;
5479
5480 BFD_ASSERT (ta == NULL || ta->offset == offset);
5481 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5482
5483 /* It is not necessary to fill at the end of a section. Clean this up. */
5484 if (sec->size == offset)
5485 new_removed = removable_space - 0;
5486 else
5487 {
5488 int space;
5489 int added = -removed - current_removed;
5490 /* Ignore multiples of the section alignment. */
5491 added = ((1 << sec->alignment_power) - 1) & added;
5492 new_removed = (-added);
5493
5494 /* Modify for removable. */
5495 space = removable_space - new_removed;
5496 new_removed = (removable_space
5497 - (((1 << sec->alignment_power) - 1) & space));
5498 }
5499 return (new_removed - current_removed);
5500}
5501
5502
7fa3d080
BW		 5503static void
5504adjust_fill_action (text_action *ta, int fill_diff)
43cd72b9
BW		 5505{
5506 ta->removed_bytes += fill_diff;
5507}
5508
5509
4c2af04f
MF		 5510static int
5511text_action_compare (splay_tree_key a, splay_tree_key b)
5512{
5513 text_action *pa = (text_action *)a;
5514 text_action *pb = (text_action *)b;
5515 static const int action_priority[] =
5516 {
5517 [ta_fill] = 0,
5518 [ta_none] = 1,
5519 [ta_convert_longcall] = 2,
5520 [ta_narrow_insn] = 3,
5521 [ta_remove_insn] = 4,
5522 [ta_remove_longcall] = 5,
5523 [ta_remove_literal] = 6,
5524 [ta_widen_insn] = 7,
5525 [ta_add_literal] = 8,
5526 };
5527
5528 if (pa->offset == pb->offset)
5529 {
5530 if (pa->action == pb->action)
5531 return 0;
5532 return action_priority[pa->action] - action_priority[pb->action];
5533 }
5534 else
5535 return pa->offset < pb->offset ? -1 : 1;
5536}
5537
5538static text_action *
5539action_first (text_action_list *action_list)
5540{
5541 splay_tree_node node = splay_tree_min (action_list->tree);
5542 return node ? (text_action *)node->value : NULL;
5543}
5544
5545static text_action *
5546action_next (text_action_list *action_list, text_action *action)
5547{
5548 splay_tree_node node = splay_tree_successor (action_list->tree,
5549 (splay_tree_key)action);
5550 return node ? (text_action *)node->value : NULL;
5551}
5552
43cd72b9
BW		 5553/* Add a modification action to the text. For the case of adding or
5554 removing space, modify any current fill and assume that
5555 "unreachable_space" bytes can be freely contracted. Note that a
5556 negative removed value is a fill. */
5557
68ffbac6 5558static void
7fa3d080
BW		 5559text_action_add (text_action_list *l,
5560 text_action_t action,
5561 asection *sec,
5562 bfd_vma offset,
5563 int removed)
43cd72b9 5564{
43cd72b9 5565 text_action *ta;
4c2af04f 5566 text_action a;
43cd72b9
BW		 5567
5568 /* It is not necessary to fill at the end of a section. */
5569 if (action == ta_fill && sec->size == offset)
5570 return;
5571
5572 /* It is not necessary to fill 0 bytes. */
5573 if (action == ta_fill && removed == 0)
5574 return;
5575
4c2af04f
MF		 5576 a.action = action;
5577 a.offset = offset;
5578
5579 if (action == ta_fill)
43cd72b9 5580 {
4c2af04f 5581 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
68ffbac6 5582
4c2af04f 5583 if (node)
43cd72b9 5584 {
4c2af04f
MF		 5585 ta = (text_action *)node->value;
5586 ta->removed_bytes += removed;
5587 return;
43cd72b9
BW		 5588 }
5589 }
4c2af04f
MF		 5590 else
5591 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
43cd72b9 5592
43cd72b9
BW		 5593 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5594 ta->action = action;
5595 ta->sec = sec;
5596 ta->offset = offset;
5597 ta->removed_bytes = removed;
4c2af04f
MF		 5598 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5599 ++l->count;
43cd72b9
BW		 5600}
5601
5602
5603static void
7fa3d080
BW		 5604text_action_add_literal (text_action_list *l,
5605 text_action_t action,
5606 const r_reloc *loc,
5607 const literal_value *value,
5608 int removed)
43cd72b9 5609{
43cd72b9
BW		 5610 text_action *ta;
5611 asection *sec = r_reloc_get_section (loc);
5612 bfd_vma offset = loc->target_offset;
5613 bfd_vma virtual_offset = loc->virtual_offset;
5614
5615 BFD_ASSERT (action == ta_add_literal);
5616
43cd72b9
BW		 5617 /* Create a new record and fill it up. */
5618 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5619 ta->action = action;
5620 ta->sec = sec;
5621 ta->offset = offset;
5622 ta->virtual_offset = virtual_offset;
5623 ta->value = *value;
5624 ta->removed_bytes = removed;
4c2af04f
MF		 5625
5626 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
5627 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5628 ++l->count;
43cd72b9
BW		 5629}
5630
5631
03669f1c
BW		 5632/* Find the total offset adjustment for the relaxations specified by
5633 text_actions, beginning from a particular starting action. This is
5634 typically used from offset_with_removed_text to search an entire list of
5635 actions, but it may also be called directly when adjusting adjacent offsets
5636 so that each search may begin where the previous one left off. */
5637
5638static int
4c2af04f
MF		 5639removed_by_actions (text_action_list *action_list,
5640 text_action **p_start_action,
03669f1c
BW		 5641 bfd_vma offset,
5642 bfd_boolean before_fill)
43cd72b9
BW		 5643{
5644 text_action *r;
5645 int removed = 0;
5646
03669f1c 5647 r = *p_start_action;
4c2af04f
MF		 5648 if (r)
5649 {
5650 splay_tree_node node = splay_tree_lookup (action_list->tree,
5651 (splay_tree_key)r);
5652 BFD_ASSERT (node != NULL && r == (text_action *)node->value);
5653 }
5654
03669f1c 5655 while (r)
43cd72b9 5656 {
03669f1c
BW		 5657 if (r->offset > offset)
5658 break;
5659
5660 if (r->offset == offset
5661 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5662 break;
5663
5664 removed += r->removed_bytes;
5665
4c2af04f 5666 r = action_next (action_list, r);
43cd72b9
BW		 5667 }
5668
03669f1c
BW		 5669 *p_start_action = r;
5670 return removed;
5671}
5672
5673
68ffbac6 5674static bfd_vma
03669f1c
BW		 5675offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5676{
4c2af04f
MF		 5677 text_action *r = action_first (action_list);
5678
5679 return offset - removed_by_actions (action_list, &r, offset, FALSE);
43cd72b9
BW		 5680}
5681
5682
03e94c08
BW		 5683static unsigned
5684action_list_count (text_action_list *action_list)
5685{
4c2af04f 5686 return action_list->count;
03e94c08
BW		 5687}
5688
4c2af04f
MF		 5689typedef struct map_action_fn_context_struct map_action_fn_context;
5690struct map_action_fn_context_struct
071aa5c9 5691{
4c2af04f 5692 int removed;
071aa5c9
MF		 5693 removal_by_action_map map;
5694 bfd_boolean eq_complete;
4c2af04f 5695};
071aa5c9 5696
4c2af04f
MF		 5697static int
5698map_action_fn (splay_tree_node node, void *p)
5699{
5700 map_action_fn_context *ctx = p;
5701 text_action *r = (text_action *)node->value;
5702 removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
071aa5c9 5703
4c2af04f 5704 if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
071aa5c9 5705 {
4c2af04f
MF		 5706 --ientry;
5707 }
5708 else
5709 {
5710 ++ctx->map.n_entries;
5711 ctx->eq_complete = FALSE;
5712 ientry->offset = r->offset;
5713 ientry->eq_removed_before_fill = ctx->removed;
5714 }
071aa5c9 5715
4c2af04f
MF		 5716 if (!ctx->eq_complete)
5717 {
5718 if (r->action != ta_fill || r->removed_bytes >= 0)
071aa5c9 5719 {
4c2af04f
MF		 5720 ientry->eq_removed = ctx->removed;
5721 ctx->eq_complete = TRUE;
071aa5c9
MF		 5722 }
5723 else
4c2af04f
MF		 5724 ientry->eq_removed = ctx->removed + r->removed_bytes;
5725 }
071aa5c9 5726
4c2af04f
MF		 5727 ctx->removed += r->removed_bytes;
5728 ientry->removed = ctx->removed;
5729 return 0;
5730}
071aa5c9 5731
4c2af04f
MF		 5732static void
5733map_removal_by_action (text_action_list *action_list)
5734{
5735 map_action_fn_context ctx;
5736
5737 ctx.removed = 0;
5738 ctx.map.n_entries = 0;
5739 ctx.map.entry = bfd_malloc (action_list_count (action_list) *
5740 sizeof (removal_by_action_entry));
5741 ctx.eq_complete = FALSE;
5742
5743 splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
5744 action_list->map = ctx.map;
071aa5c9
MF		 5745}
5746
5747static int
5748removed_by_actions_map (text_action_list *action_list, bfd_vma offset,
5749 bfd_boolean before_fill)
5750{
5751 unsigned a, b;
5752
5753 if (!action_list->map.entry)
5754 map_removal_by_action (action_list);
5755
5756 if (!action_list->map.n_entries)
5757 return 0;
5758
5759 a = 0;
5760 b = action_list->map.n_entries;
5761
5762 while (b - a > 1)
5763 {
5764 unsigned c = (a + b) / 2;
5765
5766 if (action_list->map.entry[c].offset <= offset)
5767 a = c;
5768 else
5769 b = c;
5770 }
5771
5772 if (action_list->map.entry[a].offset < offset)
5773 {
5774 return action_list->map.entry[a].removed;
5775 }
5776 else if (action_list->map.entry[a].offset == offset)
5777 {
5778 return before_fill ?
5779 action_list->map.entry[a].eq_removed_before_fill :
5780 action_list->map.entry[a].eq_removed;
5781 }
5782 else
5783 {
5784 return 0;
5785 }
5786}
5787
5788static bfd_vma
5789offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
5790{
5791 int removed = removed_by_actions_map (action_list, offset, FALSE);
5792 return offset - removed;
5793}
5794
03e94c08 5795
43cd72b9
BW		 5796/* The find_insn_action routine will only find non-fill actions. */
5797
7fa3d080
BW		 5798static text_action *
5799find_insn_action (text_action_list *action_list, bfd_vma offset)
43cd72b9 5800{
4c2af04f 5801 static const text_action_t action[] =
43cd72b9 5802 {
4c2af04f
MF		 5803 ta_convert_longcall,
5804 ta_remove_longcall,
5805 ta_widen_insn,
5806 ta_narrow_insn,
5807 ta_remove_insn,
5808 };
5809 text_action a;
5810 unsigned i;
5811
5812 a.offset = offset;
5813 for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
5814 {
5815 splay_tree_node node;
5816
5817 a.action = action[i];
5818 node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
5819 if (node)
5820 return (text_action *)node->value;
43cd72b9
BW		 5821 }
5822 return NULL;
5823}
5824
5825
5826#if DEBUG
5827
5828static void
4c2af04f
MF		 5829print_action (FILE *fp, text_action *r)
5830{
5831 const char *t = "unknown";
5832 switch (r->action)
5833 {
5834 case ta_remove_insn:
5835 t = "remove_insn"; break;
5836 case ta_remove_longcall:
5837 t = "remove_longcall"; break;
5838 case ta_convert_longcall:
5839 t = "convert_longcall"; break;
5840 case ta_narrow_insn:
5841 t = "narrow_insn"; break;
5842 case ta_widen_insn:
5843 t = "widen_insn"; break;
5844 case ta_fill:
5845 t = "fill"; break;
5846 case ta_none:
5847 t = "none"; break;
5848 case ta_remove_literal:
5849 t = "remove_literal"; break;
5850 case ta_add_literal:
5851 t = "add_literal"; break;
5852 }
5853
5854 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5855 r->sec->owner->filename,
5856 r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5857}
5858
5859static int
5860print_action_list_fn (splay_tree_node node, void *p)
43cd72b9 5861{
4c2af04f 5862 text_action *r = (text_action *)node->value;
43cd72b9 5863
4c2af04f
MF		 5864 print_action (p, r);
5865 return 0;
5866}
43cd72b9 5867
4c2af04f
MF		 5868static void
5869print_action_list (FILE *fp, text_action_list *action_list)
5870{
5871 fprintf (fp, "Text Action\n");
5872 splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
43cd72b9
BW		 5873}
5874
5875#endif /* DEBUG */
5876
5877\f
5878/* Lists of literals being coalesced or removed. */
5879
5880/* In the usual case, the literal identified by "from" is being
5881 coalesced with another literal identified by "to". If the literal is
5882 unused and is being removed altogether, "to.abfd" will be NULL.
5883 The removed_literal entries are kept on a per-section list, sorted
5884 by the "from" offset field. */
5885
5886typedef struct removed_literal_struct removed_literal;
3439c466 5887typedef struct removed_literal_map_entry_struct removed_literal_map_entry;
43cd72b9
BW		 5888typedef struct removed_literal_list_struct removed_literal_list;
5889
5890struct removed_literal_struct
5891{
5892 r_reloc from;
5893 r_reloc to;
5894 removed_literal *next;
5895};
5896
3439c466
MF		 5897struct removed_literal_map_entry_struct
5898{
5899 bfd_vma addr;
5900 removed_literal *literal;
5901};
5902
43cd72b9
BW		 5903struct removed_literal_list_struct
5904{
5905 removed_literal *head;
5906 removed_literal *tail;
3439c466
MF		 5907
5908 unsigned n_map;
5909 removed_literal_map_entry *map;
43cd72b9
BW		 5910};
5911
5912
43cd72b9
BW		 5913/* Record that the literal at "from" is being removed. If "to" is not
5914 NULL, the "from" literal is being coalesced with the "to" literal. */
5915
5916static void
7fa3d080
BW		 5917add_removed_literal (removed_literal_list *removed_list,
5918 const r_reloc *from,
5919 const r_reloc *to)
43cd72b9
BW		 5920{
5921 removed_literal *r, *new_r, *next_r;
5922
5923 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5924
5925 new_r->from = *from;
5926 if (to)
5927 new_r->to = *to;
5928 else
5929 new_r->to.abfd = NULL;
5930 new_r->next = NULL;
68ffbac6 5931
43cd72b9 5932 r = removed_list->head;
68ffbac6 5933 if (r == NULL)
43cd72b9
BW		 5934 {
5935 removed_list->head = new_r;
5936 removed_list->tail = new_r;
5937 }
5938 /* Special check for common case of append. */
5939 else if (removed_list->tail->from.target_offset < from->target_offset)
5940 {
5941 removed_list->tail->next = new_r;
5942 removed_list->tail = new_r;
5943 }
5944 else
5945 {
68ffbac6 5946 while (r->from.target_offset < from->target_offset && r->next)
43cd72b9
BW		 5947 {
5948 r = r->next;
5949 }
5950 next_r = r->next;
5951 r->next = new_r;
5952 new_r->next = next_r;
5953 if (next_r == NULL)
5954 removed_list->tail = new_r;
5955 }
5956}
5957
3439c466
MF		 5958static void
5959map_removed_literal (removed_literal_list *removed_list)
5960{
5961 unsigned n_map = 0;
5962 unsigned i;
5963 removed_literal_map_entry *map = NULL;
5964 removed_literal *r = removed_list->head;
5965
5966 for (i = 0; r; ++i, r = r->next)
5967 {
5968 if (i == n_map)
5969 {
5970 n_map = (n_map * 2) + 2;
5971 map = bfd_realloc (map, n_map * sizeof (*map));
5972 }
5973 map[i].addr = r->from.target_offset;
5974 map[i].literal = r;
5975 }
5976 removed_list->map = map;
5977 removed_list->n_map = i;
5978}
5979
5980static int
5981removed_literal_compare (const void *a, const void *b)
5982{
5983 const removed_literal_map_entry *pa = a;
5984 const removed_literal_map_entry *pb = b;
5985
5986 if (pa->addr == pb->addr)
5987 return 0;
5988 else
5989 return pa->addr < pb->addr ? -1 : 1;
5990}
43cd72b9
BW		 5991
5992/* Check if the list of removed literals contains an entry for the
5993 given address. Return the entry if found. */
5994
5995static removed_literal *
7fa3d080 5996find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
43cd72b9 5997{
3439c466
MF		 5998 removed_literal_map_entry *p;
5999 removed_literal *r = NULL;
6000
6001 if (removed_list->map == NULL)
6002 map_removed_literal (removed_list);
6003
6004 p = bsearch (&addr, removed_list->map, removed_list->n_map,
6005 sizeof (*removed_list->map), removed_literal_compare);
6006 if (p)
6007 {
6008 while (p != removed_list->map && (p - 1)->addr == addr)
6009 --p;
6010 r = p->literal;
6011 }
6012 return r;
43cd72b9
BW		 6013}
6014
6015
6016#if DEBUG
6017
6018static void
7fa3d080 6019print_removed_literals (FILE *fp, removed_literal_list *removed_list)
43cd72b9
BW		 6020{
6021 removed_literal *r;
6022 r = removed_list->head;
6023 if (r)
6024 fprintf (fp, "Removed Literals\n");
6025 for (; r != NULL; r = r->next)
6026 {
6027 print_r_reloc (fp, &r->from);
6028 fprintf (fp, " => ");
6029 if (r->to.abfd == NULL)
6030 fprintf (fp, "REMOVED");
6031 else
6032 print_r_reloc (fp, &r->to);
6033 fprintf (fp, "\n");
6034 }
6035}
6036
6037#endif /* DEBUG */
6038
6039\f
6040/* Per-section data for relaxation. */
6041
6042typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
6043
6044struct xtensa_relax_info_struct
6045{
6046 bfd_boolean is_relaxable_literal_section;
6047 bfd_boolean is_relaxable_asm_section;
6048 int visited; /* Number of times visited. */
6049
6050 source_reloc *src_relocs; /* Array[src_count]. */
6051 int src_count;
6052 int src_next; /* Next src_relocs entry to assign. */
6053
6054 removed_literal_list removed_list;
6055 text_action_list action_list;
6056
6057 reloc_bfd_fix *fix_list;
6058 reloc_bfd_fix *fix_array;
6059 unsigned fix_array_count;
6060
6061 /* Support for expanding the reloc array that is stored
6062 in the section structure. If the relocations have been
6063 reallocated, the newly allocated relocations will be referenced
6064 here along with the actual size allocated. The relocation
6065 count will always be found in the section structure. */
68ffbac6 6066 Elf_Internal_Rela *allocated_relocs;
43cd72b9
BW		 6067 unsigned relocs_count;
6068 unsigned allocated_relocs_count;
6069};
6070
6071struct elf_xtensa_section_data
6072{
6073 struct bfd_elf_section_data elf;
6074 xtensa_relax_info relax_info;
6075};
6076
43cd72b9
BW		 6077
6078static bfd_boolean
7fa3d080 6079elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
43cd72b9 6080{
f592407e
AM		 6081 if (!sec->used_by_bfd)
6082 {
6083 struct elf_xtensa_section_data *sdata;
6084 bfd_size_type amt = sizeof (*sdata);
43cd72b9 6085
f592407e
AM		 6086 sdata = bfd_zalloc (abfd, amt);
6087 if (sdata == NULL)
6088 return FALSE;
6089 sec->used_by_bfd = sdata;
6090 }
43cd72b9
BW		 6091
6092 return _bfd_elf_new_section_hook (abfd, sec);
6093}
6094
6095
7fa3d080
BW		 6096static xtensa_relax_info *
6097get_xtensa_relax_info (asection *sec)
6098{
6099 struct elf_xtensa_section_data *section_data;
6100
6101 /* No info available if no section or if it is an output section. */
6102 if (!sec || sec == sec->output_section)
6103 return NULL;
6104
6105 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
6106 return &section_data->relax_info;
6107}
6108
6109
43cd72b9 6110static void
7fa3d080 6111init_xtensa_relax_info (asection *sec)
43cd72b9
BW		 6112{
6113 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6114
6115 relax_info->is_relaxable_literal_section = FALSE;
6116 relax_info->is_relaxable_asm_section = FALSE;
6117 relax_info->visited = 0;
6118
6119 relax_info->src_relocs = NULL;
6120 relax_info->src_count = 0;
6121 relax_info->src_next = 0;
6122
6123 relax_info->removed_list.head = NULL;
6124 relax_info->removed_list.tail = NULL;
6125
4c2af04f
MF		 6126 relax_info->action_list.tree = splay_tree_new (text_action_compare,
6127 NULL, NULL);
071aa5c9
MF		 6128 relax_info->action_list.map.n_entries = 0;
6129 relax_info->action_list.map.entry = NULL;
6130
43cd72b9
BW		 6131 relax_info->fix_list = NULL;
6132 relax_info->fix_array = NULL;
6133 relax_info->fix_array_count = 0;
6134
68ffbac6 6135 relax_info->allocated_relocs = NULL;
43cd72b9
BW		 6136 relax_info->relocs_count = 0;
6137 relax_info->allocated_relocs_count = 0;
6138}
6139
43cd72b9
BW		 6140\f
6141/* Coalescing literals may require a relocation to refer to a section in
6142 a different input file, but the standard relocation information
6143 cannot express that. Instead, the reloc_bfd_fix structures are used
6144 to "fix" the relocations that refer to sections in other input files.
6145 These structures are kept on per-section lists. The "src_type" field
6146 records the relocation type in case there are multiple relocations on
6147 the same location. FIXME: This is ugly; an alternative might be to
6148 add new symbols with the "owner" field to some other input file. */
6149
6150struct reloc_bfd_fix_struct
6151{
6152 asection *src_sec;
6153 bfd_vma src_offset;
6154 unsigned src_type; /* Relocation type. */
68ffbac6 6155
43cd72b9
BW		 6156 asection *target_sec;
6157 bfd_vma target_offset;
6158 bfd_boolean translated;
68ffbac6 6159
43cd72b9
BW		 6160 reloc_bfd_fix *next;
6161};
6162
6163
43cd72b9 6164static reloc_bfd_fix *
7fa3d080
BW		 6165reloc_bfd_fix_init (asection *src_sec,
6166 bfd_vma src_offset,
6167 unsigned src_type,
7fa3d080
BW		 6168 asection *target_sec,
6169 bfd_vma target_offset,
6170 bfd_boolean translated)
43cd72b9
BW		 6171{
6172 reloc_bfd_fix *fix;
6173
6174 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
6175 fix->src_sec = src_sec;
6176 fix->src_offset = src_offset;
6177 fix->src_type = src_type;
43cd72b9
BW		 6178 fix->target_sec = target_sec;
6179 fix->target_offset = target_offset;
6180 fix->translated = translated;
6181
6182 return fix;
6183}
6184
6185
6186static void
7fa3d080 6187add_fix (asection *src_sec, reloc_bfd_fix *fix)
43cd72b9
BW		 6188{
6189 xtensa_relax_info *relax_info;
6190
6191 relax_info = get_xtensa_relax_info (src_sec);
6192 fix->next = relax_info->fix_list;
6193 relax_info->fix_list = fix;
6194}
6195
6196
6197static int
7fa3d080 6198fix_compare (const void *ap, const void *bp)
43cd72b9
BW		 6199{
6200 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
6201 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
6202
6203 if (a->src_offset != b->src_offset)
6204 return (a->src_offset - b->src_offset);
6205 return (a->src_type - b->src_type);
6206}
6207
6208
6209static void
7fa3d080 6210cache_fix_array (asection *sec)
43cd72b9
BW		 6211{
6212 unsigned i, count = 0;
6213 reloc_bfd_fix *r;
6214 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6215
6216 if (relax_info == NULL)
6217 return;
6218 if (relax_info->fix_list == NULL)
6219 return;
6220
6221 for (r = relax_info->fix_list; r != NULL; r = r->next)
6222 count++;
6223
6224 relax_info->fix_array =
6225 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6226 relax_info->fix_array_count = count;
6227
6228 r = relax_info->fix_list;
6229 for (i = 0; i < count; i++, r = r->next)
6230 {
6231 relax_info->fix_array[count - 1 - i] = *r;
6232 relax_info->fix_array[count - 1 - i].next = NULL;
6233 }
6234
6235 qsort (relax_info->fix_array, relax_info->fix_array_count,
6236 sizeof (reloc_bfd_fix), fix_compare);
6237}
6238
6239
6240static reloc_bfd_fix *
7fa3d080 6241get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
43cd72b9
BW		 6242{
6243 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6244 reloc_bfd_fix *rv;
6245 reloc_bfd_fix key;
6246
6247 if (relax_info == NULL)
6248 return NULL;
6249 if (relax_info->fix_list == NULL)
6250 return NULL;
6251
6252 if (relax_info->fix_array == NULL)
6253 cache_fix_array (sec);
6254
6255 key.src_offset = offset;
6256 key.src_type = type;
6257 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6258 sizeof (reloc_bfd_fix), fix_compare);
6259 return rv;
6260}
6261
6262\f
6263/* Section caching. */
6264
6265typedef struct section_cache_struct section_cache_t;
6266
6267struct section_cache_struct
6268{
6269 asection *sec;
6270
6271 bfd_byte *contents; /* Cache of the section contents. */
6272 bfd_size_type content_length;
6273
6274 property_table_entry *ptbl; /* Cache of the section property table. */
6275 unsigned pte_count;
6276
6277 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6278 unsigned reloc_count;
6279};
6280
6281
7fa3d080
BW		 6282static void
6283init_section_cache (section_cache_t *sec_cache)
6284{
6285 memset (sec_cache, 0, sizeof (*sec_cache));
6286}
43cd72b9
BW		 6287
6288
6289static void
65e911f9 6290free_section_cache (section_cache_t *sec_cache)
43cd72b9 6291{
7fa3d080
BW		 6292 if (sec_cache->sec)
6293 {
6294 release_contents (sec_cache->sec, sec_cache->contents);
6295 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6296 if (sec_cache->ptbl)
6297 free (sec_cache->ptbl);
7fa3d080 6298 }
43cd72b9
BW		 6299}
6300
6301
6302static bfd_boolean
7fa3d080
BW		 6303section_cache_section (section_cache_t *sec_cache,
6304 asection *sec,
6305 struct bfd_link_info *link_info)
43cd72b9
BW		 6306{
6307 bfd *abfd;
6308 property_table_entry *prop_table = NULL;
6309 int ptblsize = 0;
6310 bfd_byte *contents = NULL;
6311 Elf_Internal_Rela *internal_relocs = NULL;
6312 bfd_size_type sec_size;
6313
6314 if (sec == NULL)
6315 return FALSE;
6316 if (sec == sec_cache->sec)
6317 return TRUE;
6318
6319 abfd = sec->owner;
6320 sec_size = bfd_get_section_limit (abfd, sec);
6321
6322 /* Get the contents. */
6323 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6324 if (contents == NULL && sec_size != 0)
6325 goto err;
6326
6327 /* Get the relocations. */
6328 internal_relocs = retrieve_internal_relocs (abfd, sec,
6329 link_info->keep_memory);
6330
6331 /* Get the entry table. */
6332 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6333 XTENSA_PROP_SEC_NAME, FALSE);
6334 if (ptblsize < 0)
6335 goto err;
6336
6337 /* Fill in the new section cache. */
65e911f9
AM		 6338 free_section_cache (sec_cache);
6339 init_section_cache (sec_cache);
43cd72b9
BW		 6340
6341 sec_cache->sec = sec;
6342 sec_cache->contents = contents;
6343 sec_cache->content_length = sec_size;
6344 sec_cache->relocs = internal_relocs;
6345 sec_cache->reloc_count = sec->reloc_count;
6346 sec_cache->pte_count = ptblsize;
6347 sec_cache->ptbl = prop_table;
6348
6349 return TRUE;
6350
6351 err:
6352 release_contents (sec, contents);
6353 release_internal_relocs (sec, internal_relocs);
6354 if (prop_table)
6355 free (prop_table);
6356 return FALSE;
6357}
6358
43cd72b9
BW		 6359\f
6360/* Extended basic blocks. */
6361
6362/* An ebb_struct represents an Extended Basic Block. Within this
6363 range, we guarantee that all instructions are decodable, the
6364 property table entries are contiguous, and no property table
6365 specifies a segment that cannot have instructions moved. This
6366 structure contains caches of the contents, property table and
6367 relocations for the specified section for easy use. The range is
6368 specified by ranges of indices for the byte offset, property table
6369 offsets and relocation offsets. These must be consistent. */
6370
6371typedef struct ebb_struct ebb_t;
6372
6373struct ebb_struct
6374{
6375 asection *sec;
6376
6377 bfd_byte *contents; /* Cache of the section contents. */
6378 bfd_size_type content_length;
6379
6380 property_table_entry *ptbl; /* Cache of the section property table. */
6381 unsigned pte_count;
6382
6383 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6384 unsigned reloc_count;
6385
6386 bfd_vma start_offset; /* Offset in section. */
6387 unsigned start_ptbl_idx; /* Offset in the property table. */
6388 unsigned start_reloc_idx; /* Offset in the relocations. */
6389
6390 bfd_vma end_offset;
6391 unsigned end_ptbl_idx;
6392 unsigned end_reloc_idx;
6393
6394 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6395
6396 /* The unreachable property table at the end of this set of blocks;
6397 NULL if the end is not an unreachable block. */
6398 property_table_entry *ends_unreachable;
6399};
6400
6401
6402enum ebb_target_enum
6403{
6404 EBB_NO_ALIGN = 0,
6405 EBB_DESIRE_TGT_ALIGN,
6406 EBB_REQUIRE_TGT_ALIGN,
6407 EBB_REQUIRE_LOOP_ALIGN,
6408 EBB_REQUIRE_ALIGN
6409};
6410
6411
6412/* proposed_action_struct is similar to the text_action_struct except
6413 that is represents a potential transformation, not one that will
6414 occur. We build a list of these for an extended basic block
6415 and use them to compute the actual actions desired. We must be
6416 careful that the entire set of actual actions we perform do not
6417 break any relocations that would fit if the actions were not
6418 performed. */
6419
6420typedef struct proposed_action_struct proposed_action;
6421
6422struct proposed_action_struct
6423{
6424 enum ebb_target_enum align_type; /* for the target alignment */
6425 bfd_vma alignment_pow;
6426 text_action_t action;
6427 bfd_vma offset;
6428 int removed_bytes;
6429 bfd_boolean do_action; /* If false, then we will not perform the action. */
6430};
6431
6432
6433/* The ebb_constraint_struct keeps a set of proposed actions for an
6434 extended basic block. */
6435
6436typedef struct ebb_constraint_struct ebb_constraint;
6437
6438struct ebb_constraint_struct
6439{
6440 ebb_t ebb;
6441 bfd_boolean start_movable;
6442
6443 /* Bytes of extra space at the beginning if movable. */
6444 int start_extra_space;
6445
6446 enum ebb_target_enum start_align;
6447
6448 bfd_boolean end_movable;
6449
6450 /* Bytes of extra space at the end if movable. */
6451 int end_extra_space;
6452
6453 unsigned action_count;
6454 unsigned action_allocated;
6455
6456 /* Array of proposed actions. */
6457 proposed_action *actions;
6458
6459 /* Action alignments -- one for each proposed action. */
6460 enum ebb_target_enum *action_aligns;
6461};
6462
6463
43cd72b9 6464static void
7fa3d080 6465init_ebb_constraint (ebb_constraint *c)
43cd72b9
BW		 6466{
6467 memset (c, 0, sizeof (ebb_constraint));
6468}
6469
6470
6471static void
7fa3d080 6472free_ebb_constraint (ebb_constraint *c)
43cd72b9 6473{
7fa3d080 6474 if (c->actions)
43cd72b9
BW		 6475 free (c->actions);
6476}
6477
6478
6479static void
7fa3d080
BW		 6480init_ebb (ebb_t *ebb,
6481 asection *sec,
6482 bfd_byte *contents,
6483 bfd_size_type content_length,
6484 property_table_entry *prop_table,
6485 unsigned ptblsize,
6486 Elf_Internal_Rela *internal_relocs,
6487 unsigned reloc_count)
43cd72b9
BW		 6488{
6489 memset (ebb, 0, sizeof (ebb_t));
6490 ebb->sec = sec;
6491 ebb->contents = contents;
6492 ebb->content_length = content_length;
6493 ebb->ptbl = prop_table;
6494 ebb->pte_count = ptblsize;
6495 ebb->relocs = internal_relocs;
6496 ebb->reloc_count = reloc_count;
6497 ebb->start_offset = 0;
6498 ebb->end_offset = ebb->content_length - 1;
6499 ebb->start_ptbl_idx = 0;
6500 ebb->end_ptbl_idx = ptblsize;
6501 ebb->start_reloc_idx = 0;
6502 ebb->end_reloc_idx = reloc_count;
6503}
6504
6505
6506/* Extend the ebb to all decodable contiguous sections. The algorithm
6507 for building a basic block around an instruction is to push it
6508 forward until we hit the end of a section, an unreachable block or
6509 a block that cannot be transformed. Then we push it backwards
6510 searching for similar conditions. */
6511
7fa3d080
BW		 6512static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6513static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6514static bfd_size_type insn_block_decodable_len
6515 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6516
43cd72b9 6517static bfd_boolean
7fa3d080 6518extend_ebb_bounds (ebb_t *ebb)
43cd72b9
BW		 6519{
6520 if (!extend_ebb_bounds_forward (ebb))
6521 return FALSE;
6522 if (!extend_ebb_bounds_backward (ebb))
6523 return FALSE;
6524 return TRUE;
6525}
6526
6527
6528static bfd_boolean
7fa3d080 6529extend_ebb_bounds_forward (ebb_t *ebb)
43cd72b9
BW		 6530{
6531 property_table_entry *the_entry, *new_entry;
6532
6533 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6534
6535 /* Stop when (1) we cannot decode an instruction, (2) we are at
6536 the end of the property tables, (3) we hit a non-contiguous property
6537 table entry, (4) we hit a NO_TRANSFORM region. */
6538
6539 while (1)
6540 {
6541 bfd_vma entry_end;
6542 bfd_size_type insn_block_len;
6543
6544 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6545 insn_block_len =
6546 insn_block_decodable_len (ebb->contents, ebb->content_length,
6547 ebb->end_offset,
6548 entry_end - ebb->end_offset);
6549 if (insn_block_len != (entry_end - ebb->end_offset))
6550 {
6551 (*_bfd_error_handler)
6552 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6553 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6554 return FALSE;
6555 }
6556 ebb->end_offset += insn_block_len;
6557
6558 if (ebb->end_offset == ebb->sec->size)
6559 ebb->ends_section = TRUE;
6560
6561 /* Update the reloc counter. */
6562 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6563 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6564 < ebb->end_offset))
6565 {
6566 ebb->end_reloc_idx++;
6567 }
6568
6569 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6570 return TRUE;
6571
6572 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6573 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
99ded152 6574 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
43cd72b9
BW		 6575 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6576 break;
6577
6578 if (the_entry->address + the_entry->size != new_entry->address)
6579 break;
6580
6581 the_entry = new_entry;
6582 ebb->end_ptbl_idx++;
6583 }
6584
6585 /* Quick check for an unreachable or end of file just at the end. */
6586 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6587 {
6588 if (ebb->end_offset == ebb->content_length)
6589 ebb->ends_section = TRUE;
6590 }
6591 else
6592 {
6593 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6594 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6595 && the_entry->address + the_entry->size == new_entry->address)
6596 ebb->ends_unreachable = new_entry;
6597 }
6598
6599 /* Any other ending requires exact alignment. */
6600 return TRUE;
6601}
6602
6603
6604static bfd_boolean
7fa3d080 6605extend_ebb_bounds_backward (ebb_t *ebb)
43cd72b9
BW		 6606{
6607 property_table_entry *the_entry, *new_entry;
6608
6609 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6610
6611 /* Stop when (1) we cannot decode the instructions in the current entry.
6612 (2) we are at the beginning of the property tables, (3) we hit a
6613 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6614
6615 while (1)
6616 {
6617 bfd_vma block_begin;
6618 bfd_size_type insn_block_len;
6619
6620 block_begin = the_entry->address - ebb->sec->vma;
6621 insn_block_len =
6622 insn_block_decodable_len (ebb->contents, ebb->content_length,
6623 block_begin,
6624 ebb->start_offset - block_begin);
6625 if (insn_block_len != ebb->start_offset - block_begin)
6626 {
6627 (*_bfd_error_handler)
6628 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6629 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6630 return FALSE;
6631 }
6632 ebb->start_offset -= insn_block_len;
6633
6634 /* Update the reloc counter. */
6635 while (ebb->start_reloc_idx > 0
6636 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6637 >= ebb->start_offset))
6638 {
6639 ebb->start_reloc_idx--;
6640 }
6641
6642 if (ebb->start_ptbl_idx == 0)
6643 return TRUE;
6644
6645 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6646 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
99ded152 6647 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
43cd72b9
BW		 6648 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6649 return TRUE;
6650 if (new_entry->address + new_entry->size != the_entry->address)
6651 return TRUE;
6652
6653 the_entry = new_entry;
6654 ebb->start_ptbl_idx--;
6655 }
6656 return TRUE;
6657}
6658
6659
6660static bfd_size_type
7fa3d080
BW		 6661insn_block_decodable_len (bfd_byte *contents,
6662 bfd_size_type content_len,
6663 bfd_vma block_offset,
6664 bfd_size_type block_len)
43cd72b9
BW		 6665{
6666 bfd_vma offset = block_offset;
6667
6668 while (offset < block_offset + block_len)
6669 {
6670 bfd_size_type insn_len = 0;
6671
6672 insn_len = insn_decode_len (contents, content_len, offset);
6673 if (insn_len == 0)
6674 return (offset - block_offset);
6675 offset += insn_len;
6676 }
6677 return (offset - block_offset);
6678}
6679
6680
6681static void
7fa3d080 6682ebb_propose_action (ebb_constraint *c,
7fa3d080 6683 enum ebb_target_enum align_type,
288f74fa 6684 bfd_vma alignment_pow,
7fa3d080
BW		 6685 text_action_t action,
6686 bfd_vma offset,
6687 int removed_bytes,
6688 bfd_boolean do_action)
43cd72b9 6689{
b08b5071 6690 proposed_action *act;
43cd72b9 6691
43cd72b9
BW		 6692 if (c->action_allocated <= c->action_count)
6693 {
b08b5071 6694 unsigned new_allocated, i;
823fc61f 6695 proposed_action *new_actions;
b08b5071
BW		 6696
6697 new_allocated = (c->action_count + 2) * 2;
823fc61f 6698 new_actions = (proposed_action *)
43cd72b9
BW		 6699 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6700
6701 for (i = 0; i < c->action_count; i++)
6702 new_actions[i] = c->actions[i];
7fa3d080 6703 if (c->actions)
43cd72b9
BW		 6704 free (c->actions);
6705 c->actions = new_actions;
6706 c->action_allocated = new_allocated;
6707 }
b08b5071
BW		 6708
6709 act = &c->actions[c->action_count];
6710 act->align_type = align_type;
6711 act->alignment_pow = alignment_pow;
6712 act->action = action;
6713 act->offset = offset;
6714 act->removed_bytes = removed_bytes;
6715 act->do_action = do_action;
6716
43cd72b9
BW		 6717 c->action_count++;
6718}
6719
6720\f
6721/* Access to internal relocations, section contents and symbols. */
6722
6723/* During relaxation, we need to modify relocations, section contents,
6724 and symbol definitions, and we need to keep the original values from
6725 being reloaded from the input files, i.e., we need to "pin" the
6726 modified values in memory. We also want to continue to observe the
6727 setting of the "keep-memory" flag. The following functions wrap the
6728 standard BFD functions to take care of this for us. */
6729
6730static Elf_Internal_Rela *
7fa3d080 6731retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
43cd72b9
BW		 6732{
6733 Elf_Internal_Rela *internal_relocs;
6734
6735 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6736 return NULL;
6737
6738 internal_relocs = elf_section_data (sec)->relocs;
6739 if (internal_relocs == NULL)
6740 internal_relocs = (_bfd_elf_link_read_relocs
7fa3d080 6741 (abfd, sec, NULL, NULL, keep_memory));
43cd72b9
BW		 6742 return internal_relocs;
6743}
6744
6745
6746static void
7fa3d080 6747pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 6748{
6749 elf_section_data (sec)->relocs = internal_relocs;
6750}
6751
6752
6753static void
7fa3d080 6754release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 6755{
6756 if (internal_relocs
6757 && elf_section_data (sec)->relocs != internal_relocs)
6758 free (internal_relocs);
6759}
6760
6761
6762static bfd_byte *
7fa3d080 6763retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
43cd72b9
BW		 6764{
6765 bfd_byte *contents;
6766 bfd_size_type sec_size;
6767
6768 sec_size = bfd_get_section_limit (abfd, sec);
6769 contents = elf_section_data (sec)->this_hdr.contents;
68ffbac6 6770
43cd72b9
BW		 6771 if (contents == NULL && sec_size != 0)
6772 {
6773 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6774 {
7fa3d080 6775 if (contents)
43cd72b9
BW		 6776 free (contents);
6777 return NULL;
6778 }
68ffbac6 6779 if (keep_memory)
43cd72b9
BW		 6780 elf_section_data (sec)->this_hdr.contents = contents;
6781 }
6782 return contents;
6783}
6784
6785
6786static void
7fa3d080 6787pin_contents (asection *sec, bfd_byte *contents)
43cd72b9
BW		 6788{
6789 elf_section_data (sec)->this_hdr.contents = contents;
6790}
6791
6792
6793static void
7fa3d080 6794release_contents (asection *sec, bfd_byte *contents)
43cd72b9
BW		 6795{
6796 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6797 free (contents);
6798}
6799
6800
6801static Elf_Internal_Sym *
7fa3d080 6802retrieve_local_syms (bfd *input_bfd)
43cd72b9
BW		 6803{
6804 Elf_Internal_Shdr *symtab_hdr;
6805 Elf_Internal_Sym *isymbuf;
6806 size_t locsymcount;
6807
6808 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6809 locsymcount = symtab_hdr->sh_info;
6810
6811 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6812 if (isymbuf == NULL && locsymcount != 0)
6813 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6814 NULL, NULL, NULL);
6815
6816 /* Save the symbols for this input file so they won't be read again. */
6817 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6818 symtab_hdr->contents = (unsigned char *) isymbuf;
6819
6820 return isymbuf;
6821}
6822
6823\f
6824/* Code for link-time relaxation. */
6825
6826/* Initialization for relaxation: */
7fa3d080 6827static bfd_boolean analyze_relocations (struct bfd_link_info *);
43cd72b9 6828static bfd_boolean find_relaxable_sections
7fa3d080 6829 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
43cd72b9 6830static bfd_boolean collect_source_relocs
7fa3d080 6831 (bfd *, asection *, struct bfd_link_info *);
43cd72b9 6832static bfd_boolean is_resolvable_asm_expansion
7fa3d080
BW		 6833 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6834 bfd_boolean *);
43cd72b9 6835static Elf_Internal_Rela *find_associated_l32r_irel
7fa3d080 6836 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
43cd72b9 6837static bfd_boolean compute_text_actions
7fa3d080
BW		 6838 (bfd *, asection *, struct bfd_link_info *);
6839static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6840static bfd_boolean compute_ebb_actions (ebb_constraint *);
b2b326d2 6841typedef struct reloc_range_list_struct reloc_range_list;
43cd72b9 6842static bfd_boolean check_section_ebb_pcrels_fit
b2b326d2
MF		 6843 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
6844 reloc_range_list *, const ebb_constraint *,
cb337148 6845 const xtensa_opcode *);
7fa3d080 6846static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
43cd72b9 6847static void text_action_add_proposed
7fa3d080
BW		 6848 (text_action_list *, const ebb_constraint *, asection *);
6849static int compute_fill_extra_space (property_table_entry *);
43cd72b9
BW		 6850
6851/* First pass: */
6852static bfd_boolean compute_removed_literals
7fa3d080 6853 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
43cd72b9 6854static Elf_Internal_Rela *get_irel_at_offset
7fa3d080 6855 (asection *, Elf_Internal_Rela *, bfd_vma);
68ffbac6 6856static bfd_boolean is_removable_literal
99ded152
BW		 6857 (const source_reloc *, int, const source_reloc *, int, asection *,
6858 property_table_entry *, int);
43cd72b9 6859static bfd_boolean remove_dead_literal
7fa3d080 6860 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
68ffbac6 6861 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
7fa3d080
BW		 6862static bfd_boolean identify_literal_placement
6863 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6864 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6865 source_reloc *, property_table_entry *, int, section_cache_t *,
6866 bfd_boolean);
6867static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
43cd72b9 6868static bfd_boolean coalesce_shared_literal
7fa3d080 6869 (asection *, source_reloc *, property_table_entry *, int, value_map *);
43cd72b9 6870static bfd_boolean move_shared_literal
7fa3d080
BW		 6871 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6872 int, const r_reloc *, const literal_value *, section_cache_t *);
43cd72b9
BW		 6873
6874/* Second pass: */
7fa3d080
BW		 6875static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6876static bfd_boolean translate_section_fixes (asection *);
6877static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
9b7f5d20 6878static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
43cd72b9 6879static void shrink_dynamic_reloc_sections
7fa3d080 6880 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
43cd72b9 6881static bfd_boolean move_literal
7fa3d080
BW		 6882 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6883 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
43cd72b9 6884static bfd_boolean relax_property_section
7fa3d080 6885 (bfd *, asection *, struct bfd_link_info *);
43cd72b9
BW		 6886
6887/* Third pass: */
7fa3d080 6888static bfd_boolean relax_section_symbols (bfd *, asection *);
43cd72b9
BW		 6889
6890
68ffbac6 6891static bfd_boolean
7fa3d080
BW		 6892elf_xtensa_relax_section (bfd *abfd,
6893 asection *sec,
6894 struct bfd_link_info *link_info,
6895 bfd_boolean *again)
43cd72b9
BW		 6896{
6897 static value_map_hash_table *values = NULL;
6898 static bfd_boolean relocations_analyzed = FALSE;
6899 xtensa_relax_info *relax_info;
6900
6901 if (!relocations_analyzed)
6902 {
6903 /* Do some overall initialization for relaxation. */
6904 values = value_map_hash_table_init ();
6905 if (values == NULL)
6906 return FALSE;
6907 relaxing_section = TRUE;
6908 if (!analyze_relocations (link_info))
6909 return FALSE;
6910 relocations_analyzed = TRUE;
6911 }
6912 *again = FALSE;
6913
6914 /* Don't mess with linker-created sections. */
6915 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6916 return TRUE;
6917
6918 relax_info = get_xtensa_relax_info (sec);
6919 BFD_ASSERT (relax_info != NULL);
6920
6921 switch (relax_info->visited)
6922 {
6923 case 0:
6924 /* Note: It would be nice to fold this pass into
6925 analyze_relocations, but it is important for this step that the
6926 sections be examined in link order. */
6927 if (!compute_removed_literals (abfd, sec, link_info, values))
6928 return FALSE;
6929 *again = TRUE;
6930 break;
6931
6932 case 1:
6933 if (values)
6934 value_map_hash_table_delete (values);
6935 values = NULL;
6936 if (!relax_section (abfd, sec, link_info))
6937 return FALSE;
6938 *again = TRUE;
6939 break;
6940
6941 case 2:
6942 if (!relax_section_symbols (abfd, sec))
6943 return FALSE;
6944 break;
6945 }
6946
6947 relax_info->visited++;
6948 return TRUE;
6949}
6950
6951\f
6952/* Initialization for relaxation. */
6953
6954/* This function is called once at the start of relaxation. It scans
6955 all the input sections and marks the ones that are relaxable (i.e.,
6956 literal sections with L32R relocations against them), and then
6957 collects source_reloc information for all the relocations against
6958 those relaxable sections. During this process, it also detects
6959 longcalls, i.e., calls relaxed by the assembler into indirect
6960 calls, that can be optimized back into direct calls. Within each
6961 extended basic block (ebb) containing an optimized longcall, it
6962 computes a set of "text actions" that can be performed to remove
6963 the L32R associated with the longcall while optionally preserving
6964 branch target alignments. */
6965
6966static bfd_boolean
7fa3d080 6967analyze_relocations (struct bfd_link_info *link_info)
43cd72b9
BW		 6968{
6969 bfd *abfd;
6970 asection *sec;
6971 bfd_boolean is_relaxable = FALSE;
6972
6973 /* Initialize the per-section relaxation info. */
c72f2fb2 6974 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
43cd72b9
BW		 6975 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6976 {
6977 init_xtensa_relax_info (sec);
6978 }
6979
6980 /* Mark relaxable sections (and count relocations against each one). */
c72f2fb2 6981 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
43cd72b9
BW		 6982 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6983 {
6984 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6985 return FALSE;
6986 }
6987
6988 /* Bail out if there are no relaxable sections. */
6989 if (!is_relaxable)
6990 return TRUE;
6991
6992 /* Allocate space for source_relocs. */
c72f2fb2 6993 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
43cd72b9
BW		 6994 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6995 {
6996 xtensa_relax_info *relax_info;
6997
6998 relax_info = get_xtensa_relax_info (sec);
6999 if (relax_info->is_relaxable_literal_section
7000 || relax_info->is_relaxable_asm_section)
7001 {
7002 relax_info->src_relocs = (source_reloc *)
7003 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
7004 }
25c6282a
BW		 7005 else
7006 relax_info->src_count = 0;
43cd72b9
BW		 7007 }
7008
7009 /* Collect info on relocations against each relaxable section. */
c72f2fb2 7010 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
43cd72b9
BW		 7011 for (sec = abfd->sections; sec != NULL; sec = sec->next)
7012 {
7013 if (!collect_source_relocs (abfd, sec, link_info))
7014 return FALSE;
7015 }
7016
7017 /* Compute the text actions. */
c72f2fb2 7018 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
43cd72b9
BW		 7019 for (sec = abfd->sections; sec != NULL; sec = sec->next)
7020 {
7021 if (!compute_text_actions (abfd, sec, link_info))
7022 return FALSE;
7023 }
7024
7025 return TRUE;
7026}
7027
7028
7029/* Find all the sections that might be relaxed. The motivation for
7030 this pass is that collect_source_relocs() needs to record _all_ the
7031 relocations that target each relaxable section. That is expensive
7032 and unnecessary unless the target section is actually going to be
7033 relaxed. This pass identifies all such sections by checking if
7034 they have L32Rs pointing to them. In the process, the total number
7035 of relocations targeting each section is also counted so that we
7036 know how much space to allocate for source_relocs against each
7037 relaxable literal section. */
7038
7039static bfd_boolean
7fa3d080
BW		 7040find_relaxable_sections (bfd *abfd,
7041 asection *sec,
7042 struct bfd_link_info *link_info,
7043 bfd_boolean *is_relaxable_p)
43cd72b9
BW		 7044{
7045 Elf_Internal_Rela *internal_relocs;
7046 bfd_byte *contents;
7047 bfd_boolean ok = TRUE;
7048 unsigned i;
7049 xtensa_relax_info *source_relax_info;
25c6282a 7050 bfd_boolean is_l32r_reloc;
43cd72b9
BW		 7051
7052 internal_relocs = retrieve_internal_relocs (abfd, sec,
7053 link_info->keep_memory);
68ffbac6 7054 if (internal_relocs == NULL)
43cd72b9
BW		 7055 return ok;
7056
7057 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7058 if (contents == NULL && sec->size != 0)
7059 {
7060 ok = FALSE;
7061 goto error_return;
7062 }
7063
7064 source_relax_info = get_xtensa_relax_info (sec);
68ffbac6 7065 for (i = 0; i < sec->reloc_count; i++)
43cd72b9
BW		 7066 {
7067 Elf_Internal_Rela *irel = &internal_relocs[i];
7068 r_reloc r_rel;
7069 asection *target_sec;
7070 xtensa_relax_info *target_relax_info;
7071
7072 /* If this section has not already been marked as "relaxable", and
7073 if it contains any ASM_EXPAND relocations (marking expanded
7074 longcalls) that can be optimized into direct calls, then mark
7075 the section as "relaxable". */
7076 if (source_relax_info
7077 && !source_relax_info->is_relaxable_asm_section
7078 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
7079 {
7080 bfd_boolean is_reachable = FALSE;
7081 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
7082 link_info, &is_reachable)
7083 && is_reachable)
7084 {
7085 source_relax_info->is_relaxable_asm_section = TRUE;
7086 *is_relaxable_p = TRUE;
7087 }
7088 }
7089
7090 r_reloc_init (&r_rel, abfd, irel, contents,
7091 bfd_get_section_limit (abfd, sec));
7092
7093 target_sec = r_reloc_get_section (&r_rel);
7094 target_relax_info = get_xtensa_relax_info (target_sec);
7095 if (!target_relax_info)
7096 continue;
7097
7098 /* Count PC-relative operand relocations against the target section.
7099 Note: The conditions tested here must match the conditions under
7100 which init_source_reloc is called in collect_source_relocs(). */
25c6282a
BW		 7101 is_l32r_reloc = FALSE;
7102 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7103 {
7104 xtensa_opcode opcode =
7105 get_relocation_opcode (abfd, sec, contents, irel);
7106 if (opcode != XTENSA_UNDEFINED)
7107 {
7108 is_l32r_reloc = (opcode == get_l32r_opcode ());
7109 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
7110 || is_l32r_reloc)
7111 target_relax_info->src_count++;
7112 }
7113 }
43cd72b9 7114
25c6282a 7115 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
43cd72b9
BW		 7116 {
7117 /* Mark the target section as relaxable. */
7118 target_relax_info->is_relaxable_literal_section = TRUE;
7119 *is_relaxable_p = TRUE;
7120 }
7121 }
7122
7123 error_return:
7124 release_contents (sec, contents);
7125 release_internal_relocs (sec, internal_relocs);
7126 return ok;
7127}
7128
7129
7130/* Record _all_ the relocations that point to relaxable sections, and
7131 get rid of ASM_EXPAND relocs by either converting them to
7132 ASM_SIMPLIFY or by removing them. */
7133
7134static bfd_boolean
7fa3d080
BW		 7135collect_source_relocs (bfd *abfd,
7136 asection *sec,
7137 struct bfd_link_info *link_info)
43cd72b9
BW		 7138{
7139 Elf_Internal_Rela *internal_relocs;
7140 bfd_byte *contents;
7141 bfd_boolean ok = TRUE;
7142 unsigned i;
7143 bfd_size_type sec_size;
7144
68ffbac6 7145 internal_relocs = retrieve_internal_relocs (abfd, sec,
43cd72b9 7146 link_info->keep_memory);
68ffbac6 7147 if (internal_relocs == NULL)
43cd72b9
BW		 7148 return ok;
7149
7150 sec_size = bfd_get_section_limit (abfd, sec);
7151 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7152 if (contents == NULL && sec_size != 0)
7153 {
7154 ok = FALSE;
7155 goto error_return;
7156 }
7157
7158 /* Record relocations against relaxable literal sections. */
68ffbac6 7159 for (i = 0; i < sec->reloc_count; i++)
43cd72b9
BW		 7160 {
7161 Elf_Internal_Rela *irel = &internal_relocs[i];
7162 r_reloc r_rel;
7163 asection *target_sec;
7164 xtensa_relax_info *target_relax_info;
7165
7166 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7167
7168 target_sec = r_reloc_get_section (&r_rel);
7169 target_relax_info = get_xtensa_relax_info (target_sec);
7170
7171 if (target_relax_info
7172 && (target_relax_info->is_relaxable_literal_section
7173 || target_relax_info->is_relaxable_asm_section))
7174 {
7175 xtensa_opcode opcode = XTENSA_UNDEFINED;
7176 int opnd = -1;
7177 bfd_boolean is_abs_literal = FALSE;
7178
7179 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7180 {
7181 /* None of the current alternate relocs are PC-relative,
7182 and only PC-relative relocs matter here. However, we
7183 still need to record the opcode for literal
7184 coalescing. */
7185 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7186 if (opcode == get_l32r_opcode ())
7187 {
7188 is_abs_literal = TRUE;
7189 opnd = 1;
7190 }
7191 else
7192 opcode = XTENSA_UNDEFINED;
7193 }
7194 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7195 {
7196 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7197 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7198 }
7199
7200 if (opcode != XTENSA_UNDEFINED)
7201 {
7202 int src_next = target_relax_info->src_next++;
7203 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
7204
7205 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
7206 is_abs_literal);
7207 }
7208 }
7209 }
7210
7211 /* Now get rid of ASM_EXPAND relocations. At this point, the
7212 src_relocs array for the target literal section may still be
7213 incomplete, but it must at least contain the entries for the L32R
7214 relocations associated with ASM_EXPANDs because they were just
7215 added in the preceding loop over the relocations. */
7216
68ffbac6 7217 for (i = 0; i < sec->reloc_count; i++)
43cd72b9
BW		 7218 {
7219 Elf_Internal_Rela *irel = &internal_relocs[i];
7220 bfd_boolean is_reachable;
7221
7222 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7223 &is_reachable))
7224 continue;
7225
7226 if (is_reachable)
7227 {
7228 Elf_Internal_Rela *l32r_irel;
7229 r_reloc r_rel;
7230 asection *target_sec;
7231 xtensa_relax_info *target_relax_info;
7232
7233 /* Mark the source_reloc for the L32R so that it will be
7234 removed in compute_removed_literals(), along with the
7235 associated literal. */
7236 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7237 irel, internal_relocs);
7238 if (l32r_irel == NULL)
7239 continue;
7240
7241 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7242
7243 target_sec = r_reloc_get_section (&r_rel);
7244 target_relax_info = get_xtensa_relax_info (target_sec);
7245
7246 if (target_relax_info
7247 && (target_relax_info->is_relaxable_literal_section
7248 || target_relax_info->is_relaxable_asm_section))
7249 {
7250 source_reloc *s_reloc;
7251
7252 /* Search the source_relocs for the entry corresponding to
7253 the l32r_irel. Note: The src_relocs array is not yet
7254 sorted, but it wouldn't matter anyway because we're
7255 searching by source offset instead of target offset. */
68ffbac6 7256 s_reloc = find_source_reloc (target_relax_info->src_relocs,
43cd72b9
BW		 7257 target_relax_info->src_next,
7258 sec, l32r_irel);
7259 BFD_ASSERT (s_reloc);
7260 s_reloc->is_null = TRUE;
7261 }
7262
7263 /* Convert this reloc to ASM_SIMPLIFY. */
7264 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7265 R_XTENSA_ASM_SIMPLIFY);
7266 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7267
7268 pin_internal_relocs (sec, internal_relocs);
7269 }
7270 else
7271 {
7272 /* It is resolvable but doesn't reach. We resolve now
7273 by eliminating the relocation -- the call will remain
7274 expanded into L32R/CALLX. */
7275 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7276 pin_internal_relocs (sec, internal_relocs);
7277 }
7278 }
7279
7280 error_return:
7281 release_contents (sec, contents);
7282 release_internal_relocs (sec, internal_relocs);
7283 return ok;
7284}
7285
7286
7287/* Return TRUE if the asm expansion can be resolved. Generally it can
7288 be resolved on a final link or when a partial link locates it in the
7289 same section as the target. Set "is_reachable" flag if the target of
7290 the call is within the range of a direct call, given the current VMA
7291 for this section and the target section. */
7292
7293bfd_boolean
7fa3d080
BW		 7294is_resolvable_asm_expansion (bfd *abfd,
7295 asection *sec,
7296 bfd_byte *contents,
7297 Elf_Internal_Rela *irel,
7298 struct bfd_link_info *link_info,
7299 bfd_boolean *is_reachable_p)
43cd72b9
BW		 7300{
7301 asection *target_sec;
7302 bfd_vma target_offset;
7303 r_reloc r_rel;
7304 xtensa_opcode opcode, direct_call_opcode;
7305 bfd_vma self_address;
7306 bfd_vma dest_address;
7307 bfd_boolean uses_l32r;
7308 bfd_size_type sec_size;
7309
7310 *is_reachable_p = FALSE;
7311
7312 if (contents == NULL)
7313 return FALSE;
7314
68ffbac6 7315 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
43cd72b9
BW		 7316 return FALSE;
7317
7318 sec_size = bfd_get_section_limit (abfd, sec);
7319 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7320 sec_size - irel->r_offset, &uses_l32r);
7321 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7322 if (!uses_l32r)
7323 return FALSE;
68ffbac6 7324
43cd72b9
BW		 7325 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7326 if (direct_call_opcode == XTENSA_UNDEFINED)
7327 return FALSE;
7328
7329 /* Check and see that the target resolves. */
7330 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7331 if (!r_reloc_is_defined (&r_rel))
7332 return FALSE;
7333
7334 target_sec = r_reloc_get_section (&r_rel);
7335 target_offset = r_rel.target_offset;
7336
7337 /* If the target is in a shared library, then it doesn't reach. This
7338 isn't supposed to come up because the compiler should never generate
7339 non-PIC calls on systems that use shared libraries, but the linker
7340 shouldn't crash regardless. */
7341 if (!target_sec->output_section)
7342 return FALSE;
68ffbac6 7343
43cd72b9
BW		 7344 /* For relocatable sections, we can only simplify when the output
7345 section of the target is the same as the output section of the
7346 source. */
7347 if (link_info->relocatable
7348 && (target_sec->output_section != sec->output_section
7349 || is_reloc_sym_weak (abfd, irel)))
7350 return FALSE;
7351
331ed130
SA		 7352 if (target_sec->output_section != sec->output_section)
7353 {
7354 /* If the two sections are sufficiently far away that relaxation
7355 might take the call out of range, we can't simplify. For
7356 example, a positive displacement call into another memory
7357 could get moved to a lower address due to literal removal,
7358 but the destination won't move, and so the displacment might
7359 get larger.
7360
7361 If the displacement is negative, assume the destination could
7362 move as far back as the start of the output section. The
7363 self_address will be at least as far into the output section
7364 as it is prior to relaxation.
7365
7366 If the displacement is postive, assume the destination will be in
7367 it's pre-relaxed location (because relaxation only makes sections
7368 smaller). The self_address could go all the way to the beginning
7369 of the output section. */
7370
7371 dest_address = target_sec->output_section->vma;
7372 self_address = sec->output_section->vma;
7373
7374 if (sec->output_section->vma > target_sec->output_section->vma)
7375 self_address += sec->output_offset + irel->r_offset + 3;
7376 else
7377 dest_address += bfd_get_section_limit (abfd, target_sec->output_section);
7378 /* Call targets should be four-byte aligned. */
7379 dest_address = (dest_address + 3) & ~3;
7380 }
7381 else
7382 {
7383
7384 self_address = (sec->output_section->vma
7385 + sec->output_offset + irel->r_offset + 3);
7386 dest_address = (target_sec->output_section->vma
7387 + target_sec->output_offset + target_offset);
7388 }
68ffbac6 7389
43cd72b9
BW		 7390 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7391 self_address, dest_address);
7392
7393 if ((self_address >> CALL_SEGMENT_BITS) !=
7394 (dest_address >> CALL_SEGMENT_BITS))
7395 return FALSE;
7396
7397 return TRUE;
7398}
7399
7400
7401static Elf_Internal_Rela *
7fa3d080
BW		 7402find_associated_l32r_irel (bfd *abfd,
7403 asection *sec,
7404 bfd_byte *contents,
7405 Elf_Internal_Rela *other_irel,
7406 Elf_Internal_Rela *internal_relocs)
43cd72b9
BW		 7407{
7408 unsigned i;
e0001a05 7409
68ffbac6 7410 for (i = 0; i < sec->reloc_count; i++)
43cd72b9
BW		 7411 {
7412 Elf_Internal_Rela *irel = &internal_relocs[i];
e0001a05 7413
43cd72b9
BW		 7414 if (irel == other_irel)
7415 continue;
7416 if (irel->r_offset != other_irel->r_offset)
7417 continue;
7418 if (is_l32r_relocation (abfd, sec, contents, irel))
7419 return irel;
7420 }
7421
7422 return NULL;
e0001a05
NC		 7423}
7424
7425
cb337148
BW		 7426static xtensa_opcode *
7427build_reloc_opcodes (bfd *abfd,
7428 asection *sec,
7429 bfd_byte *contents,
7430 Elf_Internal_Rela *internal_relocs)
7431{
7432 unsigned i;
7433 xtensa_opcode *reloc_opcodes =
7434 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7435 for (i = 0; i < sec->reloc_count; i++)
7436 {
7437 Elf_Internal_Rela *irel = &internal_relocs[i];
7438 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7439 }
7440 return reloc_opcodes;
7441}
7442
b2b326d2
MF		 7443struct reloc_range_struct
7444{
7445 bfd_vma addr;
7446 bfd_boolean add; /* TRUE if start of a range, FALSE otherwise. */
7447 /* Original irel index in the array of relocations for a section. */
7448 unsigned irel_index;
7449};
7450typedef struct reloc_range_struct reloc_range;
7451
7452typedef struct reloc_range_list_entry_struct reloc_range_list_entry;
7453struct reloc_range_list_entry_struct
7454{
7455 reloc_range_list_entry *next;
7456 reloc_range_list_entry *prev;
7457 Elf_Internal_Rela *irel;
7458 xtensa_opcode opcode;
7459 int opnum;
7460};
7461
7462struct reloc_range_list_struct
7463{
7464 /* The rest of the structure is only meaningful when ok is TRUE. */
7465 bfd_boolean ok;
7466
7467 unsigned n_range; /* Number of range markers. */
7468 reloc_range *range; /* Sorted range markers. */
7469
7470 unsigned first; /* Index of a first range element in the list. */
7471 unsigned last; /* One past index of a last range element in the list. */
7472
7473 unsigned n_list; /* Number of list elements. */
7474 reloc_range_list_entry *reloc; /* */
7475 reloc_range_list_entry list_root;
7476};
7477
7478static int
7479reloc_range_compare (const void *a, const void *b)
7480{
7481 const reloc_range *ra = a;
7482 const reloc_range *rb = b;
7483
7484 if (ra->addr != rb->addr)
7485 return ra->addr < rb->addr ? -1 : 1;
7486 if (ra->add != rb->add)
7487 return ra->add ? -1 : 1;
7488 return 0;
7489}
7490
7491static void
7492build_reloc_ranges (bfd *abfd, asection *sec,
7493 bfd_byte *contents,
7494 Elf_Internal_Rela *internal_relocs,
7495 xtensa_opcode *reloc_opcodes,
7496 reloc_range_list *list)
7497{
7498 unsigned i;
7499 size_t n = 0;
7500 size_t max_n = 0;
7501 reloc_range *ranges = NULL;
7502 reloc_range_list_entry *reloc =
7503 bfd_malloc (sec->reloc_count * sizeof (*reloc));
7504
7505 memset (list, 0, sizeof (*list));
7506 list->ok = TRUE;
7507
7508 for (i = 0; i < sec->reloc_count; i++)
7509 {
7510 Elf_Internal_Rela *irel = &internal_relocs[i];
7511 int r_type = ELF32_R_TYPE (irel->r_info);
7512 reloc_howto_type *howto = &elf_howto_table[r_type];
7513 r_reloc r_rel;
7514
7515 if (r_type == R_XTENSA_ASM_SIMPLIFY
7516 || r_type == R_XTENSA_32_PCREL
7517 || !howto->pc_relative)
7518 continue;
7519
7520 r_reloc_init (&r_rel, abfd, irel, contents,
7521 bfd_get_section_limit (abfd, sec));
7522
7523 if (r_reloc_get_section (&r_rel) != sec)
7524 continue;
7525
7526 if (n + 2 > max_n)
7527 {
7528 max_n = (max_n + 2) * 2;
7529 ranges = bfd_realloc (ranges, max_n * sizeof (*ranges));
7530 }
7531
7532 ranges[n].addr = irel->r_offset;
7533 ranges[n + 1].addr = r_rel.target_offset;
7534
7535 ranges[n].add = ranges[n].addr < ranges[n + 1].addr;
7536 ranges[n + 1].add = !ranges[n].add;
7537
7538 ranges[n].irel_index = i;
7539 ranges[n + 1].irel_index = i;
7540
7541 n += 2;
7542
7543 reloc[i].irel = irel;
7544
7545 /* Every relocation won't possibly be checked in the optimized version of
7546 check_section_ebb_pcrels_fit, so this needs to be done here. */
7547 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7548 {
7549 /* None of the current alternate relocs are PC-relative,
7550 and only PC-relative relocs matter here. */
7551 }
7552 else
7553 {
7554 xtensa_opcode opcode;
7555 int opnum;
7556
7557 if (reloc_opcodes)
7558 opcode = reloc_opcodes[i];
7559 else
7560 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7561
7562 if (opcode == XTENSA_UNDEFINED)
7563 {
7564 list->ok = FALSE;
7565 break;
7566 }
7567
7568 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7569 if (opnum == XTENSA_UNDEFINED)
7570 {
7571 list->ok = FALSE;
7572 break;
7573 }
7574
7575 /* Record relocation opcode and opnum as we've calculated them
7576 anyway and they won't change. */
7577 reloc[i].opcode = opcode;
7578 reloc[i].opnum = opnum;
7579 }
7580 }
7581
7582 if (list->ok)
7583 {
7584 ranges = bfd_realloc (ranges, n * sizeof (*ranges));
7585 qsort (ranges, n, sizeof (*ranges), reloc_range_compare);
7586
7587 list->n_range = n;
7588 list->range = ranges;
7589 list->reloc = reloc;
7590 list->list_root.prev = &list->list_root;
7591 list->list_root.next = &list->list_root;
7592 }
7593 else
7594 {
7595 free (ranges);
7596 free (reloc);
7597 }
7598}
7599
7600static void reloc_range_list_append (reloc_range_list *list,
7601 unsigned irel_index)
7602{
7603 reloc_range_list_entry *entry = list->reloc + irel_index;
7604
7605 entry->prev = list->list_root.prev;
7606 entry->next = &list->list_root;
7607 entry->prev->next = entry;
7608 entry->next->prev = entry;
7609 ++list->n_list;
7610}
7611
7612static void reloc_range_list_remove (reloc_range_list *list,
7613 unsigned irel_index)
7614{
7615 reloc_range_list_entry *entry = list->reloc + irel_index;
7616
7617 entry->next->prev = entry->prev;
7618 entry->prev->next = entry->next;
7619 --list->n_list;
7620}
7621
7622/* Update relocation list object so that it lists all relocations that cross
7623 [first; last] range. Range bounds should not decrease with successive
7624 invocations. */
7625static void reloc_range_list_update_range (reloc_range_list *list,
7626 bfd_vma first, bfd_vma last)
7627{
7628 /* This should not happen: EBBs are iterated from lower addresses to higher.
7629 But even if that happens there's no need to break: just flush current list
7630 and start from scratch. */
7631 if ((list->last > 0 && list->range[list->last - 1].addr > last) ||
7632 (list->first > 0 && list->range[list->first - 1].addr >= first))
7633 {
7634 list->first = 0;
7635 list->last = 0;
7636 list->n_list = 0;
7637 list->list_root.next = &list->list_root;
7638 list->list_root.prev = &list->list_root;
7639 fprintf (stderr, "%s: move backwards requested\n", __func__);
7640 }
7641
7642 for (; list->last < list->n_range &&
7643 list->range[list->last].addr <= last; ++list->last)
7644 if (list->range[list->last].add)
7645 reloc_range_list_append (list, list->range[list->last].irel_index);
7646
7647 for (; list->first < list->n_range &&
7648 list->range[list->first].addr < first; ++list->first)
7649 if (!list->range[list->first].add)
7650 reloc_range_list_remove (list, list->range[list->first].irel_index);
7651}
7652
7653static void free_reloc_range_list (reloc_range_list *list)
7654{
7655 free (list->range);
7656 free (list->reloc);
7657}
cb337148 7658
43cd72b9
BW		 7659/* The compute_text_actions function will build a list of potential
7660 transformation actions for code in the extended basic block of each
7661 longcall that is optimized to a direct call. From this list we
7662 generate a set of actions to actually perform that optimizes for
7663 space and, if not using size_opt, maintains branch target
7664 alignments.
e0001a05 7665
43cd72b9
BW		 7666 These actions to be performed are placed on a per-section list.
7667 The actual changes are performed by relax_section() in the second
7668 pass. */
7669
7670bfd_boolean
7fa3d080
BW		 7671compute_text_actions (bfd *abfd,
7672 asection *sec,
7673 struct bfd_link_info *link_info)
e0001a05 7674{
cb337148 7675 xtensa_opcode *reloc_opcodes = NULL;
43cd72b9 7676 xtensa_relax_info *relax_info;
e0001a05 7677 bfd_byte *contents;
43cd72b9 7678 Elf_Internal_Rela *internal_relocs;
e0001a05
NC		 7679 bfd_boolean ok = TRUE;
7680 unsigned i;
43cd72b9
BW		 7681 property_table_entry *prop_table = 0;
7682 int ptblsize = 0;
7683 bfd_size_type sec_size;
b2b326d2 7684 reloc_range_list relevant_relocs;
43cd72b9 7685
43cd72b9
BW		 7686 relax_info = get_xtensa_relax_info (sec);
7687 BFD_ASSERT (relax_info);
25c6282a
BW		 7688 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7689
7690 /* Do nothing if the section contains no optimized longcalls. */
43cd72b9
BW		 7691 if (!relax_info->is_relaxable_asm_section)
7692 return ok;
e0001a05
NC		 7693
7694 internal_relocs = retrieve_internal_relocs (abfd, sec,
7695 link_info->keep_memory);
e0001a05 7696
43cd72b9
BW		 7697 if (internal_relocs)
7698 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7699 internal_reloc_compare);
7700
7701 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05 7702 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 7703 if (contents == NULL && sec_size != 0)
e0001a05
NC		 7704 {
7705 ok = FALSE;
7706 goto error_return;
7707 }
7708
43cd72b9
BW		 7709 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7710 XTENSA_PROP_SEC_NAME, FALSE);
7711 if (ptblsize < 0)
7712 {
7713 ok = FALSE;
7714 goto error_return;
7715 }
7716
b2b326d2
MF		 7717 /* Precompute the opcode for each relocation. */
7718 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs);
7719
7720 build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes,
7721 &relevant_relocs);
7722
43cd72b9 7723 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 7724 {
7725 Elf_Internal_Rela *irel = &internal_relocs[i];
43cd72b9
BW		 7726 bfd_vma r_offset;
7727 property_table_entry *the_entry;
7728 int ptbl_idx;
7729 ebb_t *ebb;
7730 ebb_constraint ebb_table;
7731 bfd_size_type simplify_size;
7732
7733 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7734 continue;
7735 r_offset = irel->r_offset;
e0001a05 7736
43cd72b9
BW		 7737 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7738 if (simplify_size == 0)
7739 {
7740 (*_bfd_error_handler)
7741 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7742 sec->owner, sec, r_offset);
7743 continue;
7744 }
e0001a05 7745
43cd72b9
BW		 7746 /* If the instruction table is not around, then don't do this
7747 relaxation. */
7748 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7749 sec->vma + irel->r_offset);
7750 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7751 {
7752 text_action_add (&relax_info->action_list,
7753 ta_convert_longcall, sec, r_offset,
7754 0);
7755 continue;
7756 }
7757
7758 /* If the next longcall happens to be at the same address as an
7759 unreachable section of size 0, then skip forward. */
7760 ptbl_idx = the_entry - prop_table;
7761 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7762 && the_entry->size == 0
7763 && ptbl_idx + 1 < ptblsize
7764 && (prop_table[ptbl_idx + 1].address
7765 == prop_table[ptbl_idx].address))
7766 {
7767 ptbl_idx++;
7768 the_entry++;
7769 }
e0001a05 7770
99ded152 7771 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
43cd72b9
BW		 7772 /* NO_REORDER is OK */
7773 continue;
e0001a05 7774
43cd72b9
BW		 7775 init_ebb_constraint (&ebb_table);
7776 ebb = &ebb_table.ebb;
7777 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7778 internal_relocs, sec->reloc_count);
7779 ebb->start_offset = r_offset + simplify_size;
7780 ebb->end_offset = r_offset + simplify_size;
7781 ebb->start_ptbl_idx = ptbl_idx;
7782 ebb->end_ptbl_idx = ptbl_idx;
7783 ebb->start_reloc_idx = i;
7784 ebb->end_reloc_idx = i;
7785
7786 if (!extend_ebb_bounds (ebb)
7787 || !compute_ebb_proposed_actions (&ebb_table)
7788 || !compute_ebb_actions (&ebb_table)
7789 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
b2b326d2
MF		 7790 internal_relocs,
7791 &relevant_relocs,
7792 &ebb_table, reloc_opcodes)
43cd72b9 7793 || !check_section_ebb_reduces (&ebb_table))
e0001a05 7794 {
43cd72b9
BW		 7795 /* If anything goes wrong or we get unlucky and something does
7796 not fit, with our plan because of expansion between
7797 critical branches, just convert to a NOP. */
7798
7799 text_action_add (&relax_info->action_list,
7800 ta_convert_longcall, sec, r_offset, 0);
7801 i = ebb_table.ebb.end_reloc_idx;
7802 free_ebb_constraint (&ebb_table);
7803 continue;
e0001a05 7804 }
43cd72b9
BW		 7805
7806 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7807
7808 /* Update the index so we do not go looking at the relocations
7809 we have already processed. */
7810 i = ebb_table.ebb.end_reloc_idx;
7811 free_ebb_constraint (&ebb_table);
e0001a05
NC		 7812 }
7813
b2b326d2
MF		 7814 free_reloc_range_list (&relevant_relocs);
7815
43cd72b9 7816#if DEBUG
4c2af04f 7817 if (action_list_count (&relax_info->action_list))
43cd72b9
BW		 7818 print_action_list (stderr, &relax_info->action_list);
7819#endif
7820
7821error_return:
e0001a05
NC		 7822 release_contents (sec, contents);
7823 release_internal_relocs (sec, internal_relocs);
43cd72b9
BW		 7824 if (prop_table)
7825 free (prop_table);
cb337148
BW		 7826 if (reloc_opcodes)
7827 free (reloc_opcodes);
43cd72b9 7828
e0001a05
NC		 7829 return ok;
7830}
7831
7832
64b607e6
BW		 7833/* Do not widen an instruction if it is preceeded by a
7834 loop opcode. It might cause misalignment. */
7835
7836static bfd_boolean
7837prev_instr_is_a_loop (bfd_byte *contents,
7838 bfd_size_type content_length,
7839 bfd_size_type offset)
7840{
7841 xtensa_opcode prev_opcode;
7842
7843 if (offset < 3)
7844 return FALSE;
7845 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7846 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
68ffbac6 7847}
64b607e6
BW		 7848
7849
43cd72b9 7850/* Find all of the possible actions for an extended basic block. */
e0001a05 7851
43cd72b9 7852bfd_boolean
7fa3d080 7853compute_ebb_proposed_actions (ebb_constraint *ebb_table)
e0001a05 7854{
43cd72b9
BW		 7855 const ebb_t *ebb = &ebb_table->ebb;
7856 unsigned rel_idx = ebb->start_reloc_idx;
7857 property_table_entry *entry, *start_entry, *end_entry;
64b607e6
BW		 7858 bfd_vma offset = 0;
7859 xtensa_isa isa = xtensa_default_isa;
7860 xtensa_format fmt;
7861 static xtensa_insnbuf insnbuf = NULL;
7862 static xtensa_insnbuf slotbuf = NULL;
7863
7864 if (insnbuf == NULL)
7865 {
7866 insnbuf = xtensa_insnbuf_alloc (isa);
7867 slotbuf = xtensa_insnbuf_alloc (isa);
7868 }
e0001a05 7869
43cd72b9
BW		 7870 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7871 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
e0001a05 7872
43cd72b9 7873 for (entry = start_entry; entry <= end_entry; entry++)
e0001a05 7874 {
64b607e6 7875 bfd_vma start_offset, end_offset;
43cd72b9 7876 bfd_size_type insn_len;
e0001a05 7877
43cd72b9
BW		 7878 start_offset = entry->address - ebb->sec->vma;
7879 end_offset = entry->address + entry->size - ebb->sec->vma;
e0001a05 7880
43cd72b9
BW		 7881 if (entry == start_entry)
7882 start_offset = ebb->start_offset;
7883 if (entry == end_entry)
7884 end_offset = ebb->end_offset;
7885 offset = start_offset;
e0001a05 7886
43cd72b9
BW		 7887 if (offset == entry->address - ebb->sec->vma
7888 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7889 {
7890 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7891 BFD_ASSERT (offset != end_offset);
7892 if (offset == end_offset)
7893 return FALSE;
e0001a05 7894
43cd72b9
BW		 7895 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7896 offset);
68ffbac6 7897 if (insn_len == 0)
64b607e6
BW		 7898 goto decode_error;
7899
43cd72b9
BW		 7900 if (check_branch_target_aligned_address (offset, insn_len))
7901 align_type = EBB_REQUIRE_TGT_ALIGN;
7902
7903 ebb_propose_action (ebb_table, align_type, 0,
7904 ta_none, offset, 0, TRUE);
7905 }
7906
7907 while (offset != end_offset)
e0001a05 7908 {
43cd72b9 7909 Elf_Internal_Rela *irel;
e0001a05 7910 xtensa_opcode opcode;
e0001a05 7911
43cd72b9
BW		 7912 while (rel_idx < ebb->end_reloc_idx
7913 && (ebb->relocs[rel_idx].r_offset < offset
7914 || (ebb->relocs[rel_idx].r_offset == offset
7915 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7916 != R_XTENSA_ASM_SIMPLIFY))))
7917 rel_idx++;
7918
7919 /* Check for longcall. */
7920 irel = &ebb->relocs[rel_idx];
7921 if (irel->r_offset == offset
7922 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7923 {
7924 bfd_size_type simplify_size;
e0001a05 7925
68ffbac6 7926 simplify_size = get_asm_simplify_size (ebb->contents,
43cd72b9
BW		 7927 ebb->content_length,
7928 irel->r_offset);
7929 if (simplify_size == 0)
64b607e6 7930 goto decode_error;
43cd72b9
BW		 7931
7932 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7933 ta_convert_longcall, offset, 0, TRUE);
68ffbac6 7934
43cd72b9
BW		 7935 offset += simplify_size;
7936 continue;
7937 }
e0001a05 7938
64b607e6
BW		 7939 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7940 goto decode_error;
7941 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7942 ebb->content_length - offset);
7943 fmt = xtensa_format_decode (isa, insnbuf);
7944 if (fmt == XTENSA_UNDEFINED)
7945 goto decode_error;
7946 insn_len = xtensa_format_length (isa, fmt);
7947 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7948 goto decode_error;
7949
7950 if (xtensa_format_num_slots (isa, fmt) != 1)
43cd72b9 7951 {
64b607e6
BW		 7952 offset += insn_len;
7953 continue;
43cd72b9 7954 }
64b607e6
BW		 7955
7956 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7957 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7958 if (opcode == XTENSA_UNDEFINED)
7959 goto decode_error;
7960
43cd72b9 7961 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
99ded152 7962 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
64b607e6 7963 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
43cd72b9
BW		 7964 {
7965 /* Add an instruction narrow action. */
7966 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7967 ta_narrow_insn, offset, 0, FALSE);
43cd72b9 7968 }
99ded152 7969 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
64b607e6
BW		 7970 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7971 && ! prev_instr_is_a_loop (ebb->contents,
7972 ebb->content_length, offset))
43cd72b9
BW		 7973 {
7974 /* Add an instruction widen action. */
7975 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7976 ta_widen_insn, offset, 0, FALSE);
43cd72b9 7977 }
64b607e6 7978 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
43cd72b9
BW		 7979 {
7980 /* Check for branch targets. */
7981 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7982 ta_none, offset, 0, TRUE);
43cd72b9
BW		 7983 }
7984
7985 offset += insn_len;
e0001a05
NC		 7986 }
7987 }
7988
43cd72b9
BW		 7989 if (ebb->ends_unreachable)
7990 {
7991 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7992 ta_fill, ebb->end_offset, 0, TRUE);
7993 }
e0001a05 7994
43cd72b9 7995 return TRUE;
64b607e6
BW		 7996
7997 decode_error:
7998 (*_bfd_error_handler)
7999 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
8000 ebb->sec->owner, ebb->sec, offset);
8001 return FALSE;
43cd72b9
BW		 8002}
8003
8004
8005/* After all of the information has collected about the
8006 transformations possible in an EBB, compute the appropriate actions
8007 here in compute_ebb_actions. We still must check later to make
8008 sure that the actions do not break any relocations. The algorithm
8009 used here is pretty greedy. Basically, it removes as many no-ops
8010 as possible so that the end of the EBB has the same alignment
8011 characteristics as the original. First, it uses narrowing, then
8012 fill space at the end of the EBB, and finally widenings. If that
8013 does not work, it tries again with one fewer no-op removed. The
8014 optimization will only be performed if all of the branch targets
8015 that were aligned before transformation are also aligned after the
8016 transformation.
8017
8018 When the size_opt flag is set, ignore the branch target alignments,
8019 narrow all wide instructions, and remove all no-ops unless the end
8020 of the EBB prevents it. */
8021
8022bfd_boolean
7fa3d080 8023compute_ebb_actions (ebb_constraint *ebb_table)
43cd72b9
BW		 8024{
8025 unsigned i = 0;
8026 unsigned j;
8027 int removed_bytes = 0;
8028 ebb_t *ebb = &ebb_table->ebb;
8029 unsigned seg_idx_start = 0;
8030 unsigned seg_idx_end = 0;
8031
8032 /* We perform this like the assembler relaxation algorithm: Start by
8033 assuming all instructions are narrow and all no-ops removed; then
8034 walk through.... */
8035
8036 /* For each segment of this that has a solid constraint, check to
8037 see if there are any combinations that will keep the constraint.
8038 If so, use it. */
8039 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
e0001a05 8040 {
43cd72b9
BW		 8041 bfd_boolean requires_text_end_align = FALSE;
8042 unsigned longcall_count = 0;
8043 unsigned longcall_convert_count = 0;
8044 unsigned narrowable_count = 0;
8045 unsigned narrowable_convert_count = 0;
8046 unsigned widenable_count = 0;
8047 unsigned widenable_convert_count = 0;
e0001a05 8048
43cd72b9
BW		 8049 proposed_action *action = NULL;
8050 int align = (1 << ebb_table->ebb.sec->alignment_power);
e0001a05 8051
43cd72b9 8052 seg_idx_start = seg_idx_end;
e0001a05 8053
43cd72b9
BW		 8054 for (i = seg_idx_start; i < ebb_table->action_count; i++)
8055 {
8056 action = &ebb_table->actions[i];
8057 if (action->action == ta_convert_longcall)
8058 longcall_count++;
8059 if (action->action == ta_narrow_insn)
8060 narrowable_count++;
8061 if (action->action == ta_widen_insn)
8062 widenable_count++;
8063 if (action->action == ta_fill)
8064 break;
8065 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8066 break;
8067 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
8068 && !elf32xtensa_size_opt)
8069 break;
8070 }
8071 seg_idx_end = i;
e0001a05 8072
43cd72b9
BW		 8073 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
8074 requires_text_end_align = TRUE;
e0001a05 8075
43cd72b9
BW		 8076 if (elf32xtensa_size_opt && !requires_text_end_align
8077 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
8078 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
8079 {
8080 longcall_convert_count = longcall_count;
8081 narrowable_convert_count = narrowable_count;
8082 widenable_convert_count = 0;
8083 }
8084 else
8085 {
8086 /* There is a constraint. Convert the max number of longcalls. */
8087 narrowable_convert_count = 0;
8088 longcall_convert_count = 0;
8089 widenable_convert_count = 0;
e0001a05 8090
43cd72b9 8091 for (j = 0; j < longcall_count; j++)
e0001a05 8092 {
43cd72b9
BW		 8093 int removed = (longcall_count - j) * 3 & (align - 1);
8094 unsigned desire_narrow = (align - removed) & (align - 1);
8095 unsigned desire_widen = removed;
8096 if (desire_narrow <= narrowable_count)
8097 {
8098 narrowable_convert_count = desire_narrow;
8099 narrowable_convert_count +=
8100 (align * ((narrowable_count - narrowable_convert_count)
8101 / align));
8102 longcall_convert_count = (longcall_count - j);
8103 widenable_convert_count = 0;
8104 break;
8105 }
8106 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
8107 {
8108 narrowable_convert_count = 0;
8109 longcall_convert_count = longcall_count - j;
8110 widenable_convert_count = desire_widen;
8111 break;
8112 }
8113 }
8114 }
e0001a05 8115
43cd72b9
BW		 8116 /* Now the number of conversions are saved. Do them. */
8117 for (i = seg_idx_start; i < seg_idx_end; i++)
8118 {
8119 action = &ebb_table->actions[i];
8120 switch (action->action)
8121 {
8122 case ta_convert_longcall:
8123 if (longcall_convert_count != 0)
8124 {
8125 action->action = ta_remove_longcall;
8126 action->do_action = TRUE;
8127 action->removed_bytes += 3;
8128 longcall_convert_count--;
8129 }
8130 break;
8131 case ta_narrow_insn:
8132 if (narrowable_convert_count != 0)
8133 {
8134 action->do_action = TRUE;
8135 action->removed_bytes += 1;
8136 narrowable_convert_count--;
8137 }
8138 break;
8139 case ta_widen_insn:
8140 if (widenable_convert_count != 0)
8141 {
8142 action->do_action = TRUE;
8143 action->removed_bytes -= 1;
8144 widenable_convert_count--;
8145 }
8146 break;
8147 default:
8148 break;
e0001a05 8149 }
43cd72b9
BW		 8150 }
8151 }
e0001a05 8152
43cd72b9
BW		 8153 /* Now we move on to some local opts. Try to remove each of the
8154 remaining longcalls. */
e0001a05 8155
43cd72b9
BW		 8156 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
8157 {
8158 removed_bytes = 0;
8159 for (i = 0; i < ebb_table->action_count; i++)
e0001a05 8160 {
43cd72b9
BW		 8161 int old_removed_bytes = removed_bytes;
8162 proposed_action *action = &ebb_table->actions[i];
8163
8164 if (action->do_action && action->action == ta_convert_longcall)
8165 {
8166 bfd_boolean bad_alignment = FALSE;
8167 removed_bytes += 3;
8168 for (j = i + 1; j < ebb_table->action_count; j++)
8169 {
8170 proposed_action *new_action = &ebb_table->actions[j];
8171 bfd_vma offset = new_action->offset;
8172 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
8173 {
8174 if (!check_branch_target_aligned
8175 (ebb_table->ebb.contents,
8176 ebb_table->ebb.content_length,
8177 offset, offset - removed_bytes))
8178 {
8179 bad_alignment = TRUE;
8180 break;
8181 }
8182 }
8183 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8184 {
8185 if (!check_loop_aligned (ebb_table->ebb.contents,
8186 ebb_table->ebb.content_length,
8187 offset,
8188 offset - removed_bytes))
8189 {
8190 bad_alignment = TRUE;
8191 break;
8192 }
8193 }
8194 if (new_action->action == ta_narrow_insn
8195 && !new_action->do_action
8196 && ebb_table->ebb.sec->alignment_power == 2)
8197 {
8198 /* Narrow an instruction and we are done. */
8199 new_action->do_action = TRUE;
8200 new_action->removed_bytes += 1;
8201 bad_alignment = FALSE;
8202 break;
8203 }
8204 if (new_action->action == ta_widen_insn
8205 && new_action->do_action
8206 && ebb_table->ebb.sec->alignment_power == 2)
8207 {
8208 /* Narrow an instruction and we are done. */
8209 new_action->do_action = FALSE;
8210 new_action->removed_bytes += 1;
8211 bad_alignment = FALSE;
8212 break;
8213 }
5c5d6806
BW		 8214 if (new_action->do_action)
8215 removed_bytes += new_action->removed_bytes;
43cd72b9
BW		 8216 }
8217 if (!bad_alignment)
8218 {
8219 action->removed_bytes += 3;
8220 action->action = ta_remove_longcall;
8221 action->do_action = TRUE;
8222 }
8223 }
8224 removed_bytes = old_removed_bytes;
8225 if (action->do_action)
8226 removed_bytes += action->removed_bytes;
e0001a05
NC		 8227 }
8228 }
8229
43cd72b9
BW		 8230 removed_bytes = 0;
8231 for (i = 0; i < ebb_table->action_count; ++i)
8232 {
8233 proposed_action *action = &ebb_table->actions[i];
8234 if (action->do_action)
8235 removed_bytes += action->removed_bytes;
8236 }
8237
8238 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
8239 && ebb->ends_unreachable)
8240 {
8241 proposed_action *action;
8242 int br;
8243 int extra_space;
8244
8245 BFD_ASSERT (ebb_table->action_count != 0);
8246 action = &ebb_table->actions[ebb_table->action_count - 1];
8247 BFD_ASSERT (action->action == ta_fill);
8248 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
8249
8250 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
8251 br = action->removed_bytes + removed_bytes + extra_space;
8252 br = br & ((1 << ebb->sec->alignment_power ) - 1);
8253
8254 action->removed_bytes = extra_space - br;
8255 }
8256 return TRUE;
e0001a05
NC		 8257}
8258
8259
03e94c08
BW		 8260/* The xlate_map is a sorted array of address mappings designed to
8261 answer the offset_with_removed_text() query with a binary search instead
8262 of a linear search through the section's action_list. */
8263
8264typedef struct xlate_map_entry xlate_map_entry_t;
8265typedef struct xlate_map xlate_map_t;
8266
8267struct xlate_map_entry
8268{
8269 unsigned orig_address;
8270 unsigned new_address;
8271 unsigned size;
8272};
8273
8274struct xlate_map
8275{
8276 unsigned entry_count;
8277 xlate_map_entry_t *entry;
8278};
8279
8280
68ffbac6 8281static int
03e94c08
BW		 8282xlate_compare (const void *a_v, const void *b_v)
8283{
8284 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
8285 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
8286 if (a->orig_address < b->orig_address)
8287 return -1;
8288 if (a->orig_address > (b->orig_address + b->size - 1))
8289 return 1;
8290 return 0;
8291}
8292
8293
8294static bfd_vma
8295xlate_offset_with_removed_text (const xlate_map_t *map,
8296 text_action_list *action_list,
8297 bfd_vma offset)
8298{
03e94c08
BW		 8299 void *r;
8300 xlate_map_entry_t *e;
8301
8302 if (map == NULL)
8303 return offset_with_removed_text (action_list, offset);
8304
8305 if (map->entry_count == 0)
8306 return offset;
8307
03e94c08
BW		 8308 r = bsearch (&offset, map->entry, map->entry_count,
8309 sizeof (xlate_map_entry_t), &xlate_compare);
8310 e = (xlate_map_entry_t *) r;
68ffbac6 8311
03e94c08
BW		 8312 BFD_ASSERT (e != NULL);
8313 if (e == NULL)
8314 return offset;
8315 return e->new_address - e->orig_address + offset;
8316}
8317
4c2af04f
MF		 8318typedef struct xlate_map_context_struct xlate_map_context;
8319struct xlate_map_context_struct
8320{
8321 xlate_map_t *map;
8322 xlate_map_entry_t *current_entry;
8323 int removed;
8324};
8325
8326static int
8327xlate_map_fn (splay_tree_node node, void *p)
8328{
8329 text_action *r = (text_action *)node->value;
8330 xlate_map_context *ctx = p;
8331 unsigned orig_size = 0;
8332
8333 switch (r->action)
8334 {
8335 case ta_none:
8336 case ta_remove_insn:
8337 case ta_convert_longcall:
8338 case ta_remove_literal:
8339 case ta_add_literal:
8340 break;
8341 case ta_remove_longcall:
8342 orig_size = 6;
8343 break;
8344 case ta_narrow_insn:
8345 orig_size = 3;
8346 break;
8347 case ta_widen_insn:
8348 orig_size = 2;
8349 break;
8350 case ta_fill:
8351 break;
8352 }
8353 ctx->current_entry->size =
8354 r->offset + orig_size - ctx->current_entry->orig_address;
8355 if (ctx->current_entry->size != 0)
8356 {
8357 ctx->current_entry++;
8358 ctx->map->entry_count++;
8359 }
8360 ctx->current_entry->orig_address = r->offset + orig_size;
8361 ctx->removed += r->removed_bytes;
8362 ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
8363 ctx->current_entry->size = 0;
8364 return 0;
8365}
03e94c08
BW		 8366
8367/* Build a binary searchable offset translation map from a section's
8368 action list. */
8369
8370static xlate_map_t *
8371build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
8372{
03e94c08
BW		 8373 text_action_list *action_list = &relax_info->action_list;
8374 unsigned num_actions = 0;
4c2af04f 8375 xlate_map_context ctx;
03e94c08 8376
4c2af04f
MF		 8377 ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
8378
8379 if (ctx.map == NULL)
03e94c08
BW		 8380 return NULL;
8381
8382 num_actions = action_list_count (action_list);
4c2af04f 8383 ctx.map->entry = (xlate_map_entry_t *)
03e94c08 8384 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
4c2af04f 8385 if (ctx.map->entry == NULL)
03e94c08 8386 {
4c2af04f 8387 free (ctx.map);
03e94c08
BW		 8388 return NULL;
8389 }
4c2af04f 8390 ctx.map->entry_count = 0;
68ffbac6 8391
4c2af04f
MF		 8392 ctx.removed = 0;
8393 ctx.current_entry = &ctx.map->entry[0];
03e94c08 8394
4c2af04f
MF		 8395 ctx.current_entry->orig_address = 0;
8396 ctx.current_entry->new_address = 0;
8397 ctx.current_entry->size = 0;
03e94c08 8398
4c2af04f 8399 splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
03e94c08 8400
4c2af04f
MF		 8401 ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
8402 - ctx.current_entry->orig_address);
8403 if (ctx.current_entry->size != 0)
8404 ctx.map->entry_count++;
03e94c08 8405
4c2af04f 8406 return ctx.map;
03e94c08
BW		 8407}
8408
8409
8410/* Free an offset translation map. */
8411
68ffbac6 8412static void
03e94c08
BW		 8413free_xlate_map (xlate_map_t *map)
8414{
8415 if (map && map->entry)
8416 free (map->entry);
8417 if (map)
8418 free (map);
8419}
8420
8421
43cd72b9
BW		 8422/* Use check_section_ebb_pcrels_fit to make sure that all of the
8423 relocations in a section will fit if a proposed set of actions
8424 are performed. */
e0001a05 8425
43cd72b9 8426static bfd_boolean
7fa3d080
BW		 8427check_section_ebb_pcrels_fit (bfd *abfd,
8428 asection *sec,
8429 bfd_byte *contents,
8430 Elf_Internal_Rela *internal_relocs,
b2b326d2 8431 reloc_range_list *relevant_relocs,
cb337148
BW		 8432 const ebb_constraint *constraint,
8433 const xtensa_opcode *reloc_opcodes)
e0001a05 8434{
43cd72b9 8435 unsigned i, j;
b2b326d2 8436 unsigned n = sec->reloc_count;
43cd72b9 8437 Elf_Internal_Rela *irel;
03e94c08
BW		 8438 xlate_map_t *xmap = NULL;
8439 bfd_boolean ok = TRUE;
43cd72b9 8440 xtensa_relax_info *relax_info;
b2b326d2 8441 reloc_range_list_entry *entry = NULL;
e0001a05 8442
43cd72b9 8443 relax_info = get_xtensa_relax_info (sec);
e0001a05 8444
03e94c08
BW		 8445 if (relax_info && sec->reloc_count > 100)
8446 {
8447 xmap = build_xlate_map (sec, relax_info);
8448 /* NULL indicates out of memory, but the slow version
8449 can still be used. */
8450 }
8451
b2b326d2
MF		 8452 if (relevant_relocs && constraint->action_count)
8453 {
8454 if (!relevant_relocs->ok)
8455 {
8456 ok = FALSE;
8457 n = 0;
8458 }
8459 else
8460 {
8461 bfd_vma min_offset, max_offset;
8462 min_offset = max_offset = constraint->actions[0].offset;
8463
8464 for (i = 1; i < constraint->action_count; ++i)
8465 {
8466 proposed_action *action = &constraint->actions[i];
8467 bfd_vma offset = action->offset;
8468
8469 if (offset < min_offset)
8470 min_offset = offset;
8471 if (offset > max_offset)
8472 max_offset = offset;
8473 }
8474 reloc_range_list_update_range (relevant_relocs, min_offset,
8475 max_offset);
8476 n = relevant_relocs->n_list;
8477 entry = &relevant_relocs->list_root;
8478 }
8479 }
8480 else
8481 {
8482 relevant_relocs = NULL;
8483 }
8484
8485 for (i = 0; i < n; i++)
43cd72b9
BW		 8486 {
8487 r_reloc r_rel;
8488 bfd_vma orig_self_offset, orig_target_offset;
8489 bfd_vma self_offset, target_offset;
8490 int r_type;
8491 reloc_howto_type *howto;
8492 int self_removed_bytes, target_removed_bytes;
e0001a05 8493
b2b326d2
MF		 8494 if (relevant_relocs)
8495 {
8496 entry = entry->next;
8497 irel = entry->irel;
8498 }
8499 else
8500 {
8501 irel = internal_relocs + i;
8502 }
43cd72b9 8503 r_type = ELF32_R_TYPE (irel->r_info);
e0001a05 8504
43cd72b9
BW		 8505 howto = &elf_howto_table[r_type];
8506 /* We maintain the required invariant: PC-relative relocations
8507 that fit before linking must fit after linking. Thus we only
8508 need to deal with relocations to the same section that are
8509 PC-relative. */
1bbb5f21
BW		 8510 if (r_type == R_XTENSA_ASM_SIMPLIFY
8511 || r_type == R_XTENSA_32_PCREL
43cd72b9
BW		 8512 || !howto->pc_relative)
8513 continue;
e0001a05 8514
43cd72b9
BW		 8515 r_reloc_init (&r_rel, abfd, irel, contents,
8516 bfd_get_section_limit (abfd, sec));
e0001a05 8517
43cd72b9
BW		 8518 if (r_reloc_get_section (&r_rel) != sec)
8519 continue;
e0001a05 8520
43cd72b9
BW		 8521 orig_self_offset = irel->r_offset;
8522 orig_target_offset = r_rel.target_offset;
e0001a05 8523
43cd72b9
BW		 8524 self_offset = orig_self_offset;
8525 target_offset = orig_target_offset;
8526
8527 if (relax_info)
8528 {
03e94c08
BW		 8529 self_offset =
8530 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8531 orig_self_offset);
8532 target_offset =
8533 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8534 orig_target_offset);
43cd72b9
BW		 8535 }
8536
8537 self_removed_bytes = 0;
8538 target_removed_bytes = 0;
8539
8540 for (j = 0; j < constraint->action_count; ++j)
8541 {
8542 proposed_action *action = &constraint->actions[j];
8543 bfd_vma offset = action->offset;
8544 int removed_bytes = action->removed_bytes;
8545 if (offset < orig_self_offset
8546 || (offset == orig_self_offset && action->action == ta_fill
8547 && action->removed_bytes < 0))
8548 self_removed_bytes += removed_bytes;
8549 if (offset < orig_target_offset
8550 || (offset == orig_target_offset && action->action == ta_fill
8551 && action->removed_bytes < 0))
8552 target_removed_bytes += removed_bytes;
8553 }
8554 self_offset -= self_removed_bytes;
8555 target_offset -= target_removed_bytes;
8556
8557 /* Try to encode it. Get the operand and check. */
8558 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8559 {
8560 /* None of the current alternate relocs are PC-relative,
8561 and only PC-relative relocs matter here. */
8562 }
8563 else
8564 {
8565 xtensa_opcode opcode;
8566 int opnum;
8567
b2b326d2 8568 if (relevant_relocs)
03e94c08 8569 {
b2b326d2
MF		 8570 opcode = entry->opcode;
8571 opnum = entry->opnum;
03e94c08 8572 }
b2b326d2 8573 else
03e94c08 8574 {
b2b326d2
MF		 8575 if (reloc_opcodes)
8576 opcode = reloc_opcodes[relevant_relocs ?
8577 (unsigned)(entry - relevant_relocs->reloc) : i];
8578 else
8579 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8580 if (opcode == XTENSA_UNDEFINED)
8581 {
8582 ok = FALSE;
8583 break;
8584 }
8585
8586 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8587 if (opnum == XTENSA_UNDEFINED)
8588 {
8589 ok = FALSE;
8590 break;
8591 }
03e94c08 8592 }
43cd72b9
BW		 8593
8594 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
03e94c08
BW		 8595 {
8596 ok = FALSE;
8597 break;
8598 }
43cd72b9
BW		 8599 }
8600 }
8601
03e94c08
BW		 8602 if (xmap)
8603 free_xlate_map (xmap);
8604
8605 return ok;
43cd72b9
BW		 8606}
8607
8608
8609static bfd_boolean
7fa3d080 8610check_section_ebb_reduces (const ebb_constraint *constraint)
43cd72b9
BW		 8611{
8612 int removed = 0;
8613 unsigned i;
8614
8615 for (i = 0; i < constraint->action_count; i++)
8616 {
8617 const proposed_action *action = &constraint->actions[i];
8618 if (action->do_action)
8619 removed += action->removed_bytes;
8620 }
8621 if (removed < 0)
e0001a05
NC		 8622 return FALSE;
8623
8624 return TRUE;
8625}
8626
8627
43cd72b9 8628void
7fa3d080
BW		 8629text_action_add_proposed (text_action_list *l,
8630 const ebb_constraint *ebb_table,
8631 asection *sec)
e0001a05
NC		 8632{
8633 unsigned i;
8634
43cd72b9 8635 for (i = 0; i < ebb_table->action_count; i++)
e0001a05 8636 {
43cd72b9 8637 proposed_action *action = &ebb_table->actions[i];
e0001a05 8638
43cd72b9 8639 if (!action->do_action)
e0001a05 8640 continue;
43cd72b9
BW		 8641 switch (action->action)
8642 {
8643 case ta_remove_insn:
8644 case ta_remove_longcall:
8645 case ta_convert_longcall:
8646 case ta_narrow_insn:
8647 case ta_widen_insn:
8648 case ta_fill:
8649 case ta_remove_literal:
8650 text_action_add (l, action->action, sec, action->offset,
8651 action->removed_bytes);
8652 break;
8653 case ta_none:
8654 break;
8655 default:
8656 BFD_ASSERT (0);
8657 break;
8658 }
e0001a05 8659 }
43cd72b9 8660}
e0001a05 8661
43cd72b9
BW		 8662
8663int
7fa3d080 8664compute_fill_extra_space (property_table_entry *entry)
43cd72b9
BW		 8665{
8666 int fill_extra_space;
8667
8668 if (!entry)
8669 return 0;
8670
8671 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8672 return 0;
8673
8674 fill_extra_space = entry->size;
8675 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8676 {
8677 /* Fill bytes for alignment:
8678 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8679 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8680 int nsm = (1 << pow) - 1;
8681 bfd_vma addr = entry->address + entry->size;
8682 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8683 fill_extra_space += align_fill;
8684 }
8685 return fill_extra_space;
e0001a05
NC		 8686}
8687
43cd72b9 8688\f
e0001a05
NC		 8689/* First relaxation pass. */
8690
43cd72b9
BW		 8691/* If the section contains relaxable literals, check each literal to
8692 see if it has the same value as another literal that has already
8693 been seen, either in the current section or a previous one. If so,
8694 add an entry to the per-section list of removed literals. The
e0001a05
NC		 8695 actual changes are deferred until the next pass. */
8696
68ffbac6 8697static bfd_boolean
7fa3d080
BW		 8698compute_removed_literals (bfd *abfd,
8699 asection *sec,
8700 struct bfd_link_info *link_info,
8701 value_map_hash_table *values)
e0001a05
NC		 8702{
8703 xtensa_relax_info *relax_info;
8704 bfd_byte *contents;
8705 Elf_Internal_Rela *internal_relocs;
43cd72b9 8706 source_reloc *src_relocs, *rel;
e0001a05 8707 bfd_boolean ok = TRUE;
43cd72b9
BW		 8708 property_table_entry *prop_table = NULL;
8709 int ptblsize;
8710 int i, prev_i;
8711 bfd_boolean last_loc_is_prev = FALSE;
8712 bfd_vma last_target_offset = 0;
8713 section_cache_t target_sec_cache;
8714 bfd_size_type sec_size;
8715
8716 init_section_cache (&target_sec_cache);
e0001a05
NC		 8717
8718 /* Do nothing if it is not a relaxable literal section. */
8719 relax_info = get_xtensa_relax_info (sec);
8720 BFD_ASSERT (relax_info);
e0001a05
NC		 8721 if (!relax_info->is_relaxable_literal_section)
8722 return ok;
8723
68ffbac6 8724 internal_relocs = retrieve_internal_relocs (abfd, sec,
e0001a05
NC		 8725 link_info->keep_memory);
8726
43cd72b9 8727 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05 8728 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 8729 if (contents == NULL && sec_size != 0)
e0001a05
NC		 8730 {
8731 ok = FALSE;
8732 goto error_return;
8733 }
8734
8735 /* Sort the source_relocs by target offset. */
8736 src_relocs = relax_info->src_relocs;
8737 qsort (src_relocs, relax_info->src_count,
8738 sizeof (source_reloc), source_reloc_compare);
43cd72b9
BW		 8739 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8740 internal_reloc_compare);
e0001a05 8741
43cd72b9
BW		 8742 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8743 XTENSA_PROP_SEC_NAME, FALSE);
8744 if (ptblsize < 0)
8745 {
8746 ok = FALSE;
8747 goto error_return;
8748 }
8749
8750 prev_i = -1;
e0001a05
NC		 8751 for (i = 0; i < relax_info->src_count; i++)
8752 {
e0001a05 8753 Elf_Internal_Rela *irel = NULL;
e0001a05
NC		 8754
8755 rel = &src_relocs[i];
43cd72b9
BW		 8756 if (get_l32r_opcode () != rel->opcode)
8757 continue;
e0001a05
NC		 8758 irel = get_irel_at_offset (sec, internal_relocs,
8759 rel->r_rel.target_offset);
8760
43cd72b9
BW		 8761 /* If the relocation on this is not a simple R_XTENSA_32 or
8762 R_XTENSA_PLT then do not consider it. This may happen when
8763 the difference of two symbols is used in a literal. */
8764 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8765 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8766 continue;
8767
e0001a05
NC		 8768 /* If the target_offset for this relocation is the same as the
8769 previous relocation, then we've already considered whether the
8770 literal can be coalesced. Skip to the next one.... */
43cd72b9
BW		 8771 if (i != 0 && prev_i != -1
8772 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
e0001a05 8773 continue;
43cd72b9
BW		 8774 prev_i = i;
8775
68ffbac6 8776 if (last_loc_is_prev &&
43cd72b9
BW		 8777 last_target_offset + 4 != rel->r_rel.target_offset)
8778 last_loc_is_prev = FALSE;
e0001a05
NC		 8779
8780 /* Check if the relocation was from an L32R that is being removed
8781 because a CALLX was converted to a direct CALL, and check if
8782 there are no other relocations to the literal. */
68ffbac6 8783 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
99ded152 8784 sec, prop_table, ptblsize))
e0001a05 8785 {
43cd72b9
BW		 8786 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8787 irel, rel, prop_table, ptblsize))
e0001a05 8788 {
43cd72b9
BW		 8789 ok = FALSE;
8790 goto error_return;
e0001a05 8791 }
43cd72b9 8792 last_target_offset = rel->r_rel.target_offset;
e0001a05
NC		 8793 continue;
8794 }
8795
43cd72b9 8796 if (!identify_literal_placement (abfd, sec, contents, link_info,
68ffbac6
L		 8797 values,
8798 &last_loc_is_prev, irel,
43cd72b9
BW		 8799 relax_info->src_count - i, rel,
8800 prop_table, ptblsize,
8801 &target_sec_cache, rel->is_abs_literal))
e0001a05 8802 {
43cd72b9
BW		 8803 ok = FALSE;
8804 goto error_return;
8805 }
8806 last_target_offset = rel->r_rel.target_offset;
8807 }
e0001a05 8808
43cd72b9
BW		 8809#if DEBUG
8810 print_removed_literals (stderr, &relax_info->removed_list);
8811 print_action_list (stderr, &relax_info->action_list);
8812#endif /* DEBUG */
8813
8814error_return:
65e911f9
AM		 8815 if (prop_table)
8816 free (prop_table);
8817 free_section_cache (&target_sec_cache);
43cd72b9
BW		 8818
8819 release_contents (sec, contents);
8820 release_internal_relocs (sec, internal_relocs);
8821 return ok;
8822}
8823
8824
8825static Elf_Internal_Rela *
7fa3d080
BW		 8826get_irel_at_offset (asection *sec,
8827 Elf_Internal_Rela *internal_relocs,
8828 bfd_vma offset)
43cd72b9
BW		 8829{
8830 unsigned i;
8831 Elf_Internal_Rela *irel;
8832 unsigned r_type;
8833 Elf_Internal_Rela key;
8834
68ffbac6 8835 if (!internal_relocs)
43cd72b9
BW		 8836 return NULL;
8837
8838 key.r_offset = offset;
8839 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8840 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8841 if (!irel)
8842 return NULL;
8843
8844 /* bsearch does not guarantee which will be returned if there are
8845 multiple matches. We need the first that is not an alignment. */
8846 i = irel - internal_relocs;
8847 while (i > 0)
8848 {
8849 if (internal_relocs[i-1].r_offset != offset)
8850 break;
8851 i--;
8852 }
8853 for ( ; i < sec->reloc_count; i++)
8854 {
8855 irel = &internal_relocs[i];
8856 r_type = ELF32_R_TYPE (irel->r_info);
8857 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8858 return irel;
8859 }
8860
8861 return NULL;
8862}
8863
8864
8865bfd_boolean
7fa3d080
BW		 8866is_removable_literal (const source_reloc *rel,
8867 int i,
8868 const source_reloc *src_relocs,
99ded152
BW		 8869 int src_count,
8870 asection *sec,
8871 property_table_entry *prop_table,
8872 int ptblsize)
43cd72b9
BW		 8873{
8874 const source_reloc *curr_rel;
99ded152
BW		 8875 property_table_entry *entry;
8876
43cd72b9
BW		 8877 if (!rel->is_null)
8878 return FALSE;
68ffbac6
L		 8879
8880 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
99ded152
BW		 8881 sec->vma + rel->r_rel.target_offset);
8882 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8883 return FALSE;
8884
43cd72b9
BW		 8885 for (++i; i < src_count; ++i)
8886 {
8887 curr_rel = &src_relocs[i];
8888 /* If all others have the same target offset.... */
8889 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8890 return TRUE;
8891
8892 if (!curr_rel->is_null
8893 && !xtensa_is_property_section (curr_rel->source_sec)
8894 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8895 return FALSE;
8896 }
8897 return TRUE;
8898}
8899
8900
68ffbac6 8901bfd_boolean
7fa3d080
BW		 8902remove_dead_literal (bfd *abfd,
8903 asection *sec,
8904 struct bfd_link_info *link_info,
8905 Elf_Internal_Rela *internal_relocs,
8906 Elf_Internal_Rela *irel,
8907 source_reloc *rel,
8908 property_table_entry *prop_table,
8909 int ptblsize)
43cd72b9
BW		 8910{
8911 property_table_entry *entry;
8912 xtensa_relax_info *relax_info;
8913
8914 relax_info = get_xtensa_relax_info (sec);
8915 if (!relax_info)
8916 return FALSE;
8917
8918 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8919 sec->vma + rel->r_rel.target_offset);
8920
8921 /* Mark the unused literal so that it will be removed. */
8922 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8923
8924 text_action_add (&relax_info->action_list,
8925 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8926
8927 /* If the section is 4-byte aligned, do not add fill. */
68ffbac6 8928 if (sec->alignment_power > 2)
43cd72b9
BW		 8929 {
8930 int fill_extra_space;
8931 bfd_vma entry_sec_offset;
8932 text_action *fa;
8933 property_table_entry *the_add_entry;
8934 int removed_diff;
8935
8936 if (entry)
8937 entry_sec_offset = entry->address - sec->vma + entry->size;
8938 else
8939 entry_sec_offset = rel->r_rel.target_offset + 4;
8940
8941 /* If the literal range is at the end of the section,
8942 do not add fill. */
8943 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8944 entry_sec_offset);
8945 fill_extra_space = compute_fill_extra_space (the_add_entry);
8946
8947 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8948 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8949 -4, fill_extra_space);
8950 if (fa)
8951 adjust_fill_action (fa, removed_diff);
8952 else
8953 text_action_add (&relax_info->action_list,
8954 ta_fill, sec, entry_sec_offset, removed_diff);
8955 }
8956
8957 /* Zero out the relocation on this literal location. */
8958 if (irel)
8959 {
8960 if (elf_hash_table (link_info)->dynamic_sections_created)
8961 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8962
8963 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8964 pin_internal_relocs (sec, internal_relocs);
8965 }
8966
8967 /* Do not modify "last_loc_is_prev". */
8968 return TRUE;
8969}
8970
8971
68ffbac6 8972bfd_boolean
7fa3d080
BW		 8973identify_literal_placement (bfd *abfd,
8974 asection *sec,
8975 bfd_byte *contents,
8976 struct bfd_link_info *link_info,
8977 value_map_hash_table *values,
8978 bfd_boolean *last_loc_is_prev_p,
8979 Elf_Internal_Rela *irel,
8980 int remaining_src_rels,
8981 source_reloc *rel,
8982 property_table_entry *prop_table,
8983 int ptblsize,
8984 section_cache_t *target_sec_cache,
8985 bfd_boolean is_abs_literal)
43cd72b9
BW		 8986{
8987 literal_value val;
8988 value_map *val_map;
8989 xtensa_relax_info *relax_info;
8990 bfd_boolean literal_placed = FALSE;
8991 r_reloc r_rel;
8992 unsigned long value;
8993 bfd_boolean final_static_link;
8994 bfd_size_type sec_size;
8995
8996 relax_info = get_xtensa_relax_info (sec);
8997 if (!relax_info)
8998 return FALSE;
8999
9000 sec_size = bfd_get_section_limit (abfd, sec);
9001
9002 final_static_link =
9003 (!link_info->relocatable
9004 && !elf_hash_table (link_info)->dynamic_sections_created);
9005
9006 /* The placement algorithm first checks to see if the literal is
9007 already in the value map. If so and the value map is reachable
9008 from all uses, then the literal is moved to that location. If
9009 not, then we identify the last location where a fresh literal was
9010 placed. If the literal can be safely moved there, then we do so.
9011 If not, then we assume that the literal is not to move and leave
9012 the literal where it is, marking it as the last literal
9013 location. */
9014
9015 /* Find the literal value. */
9016 value = 0;
9017 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9018 if (!irel)
9019 {
9020 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
9021 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
9022 }
9023 init_literal_value (&val, &r_rel, value, is_abs_literal);
9024
9025 /* Check if we've seen another literal with the same value that
9026 is in the same output section. */
9027 val_map = value_map_get_cached_value (values, &val, final_static_link);
9028
9029 if (val_map
9030 && (r_reloc_get_section (&val_map->loc)->output_section
9031 == sec->output_section)
9032 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
9033 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
9034 {
9035 /* No change to last_loc_is_prev. */
9036 literal_placed = TRUE;
9037 }
9038
9039 /* For relocatable links, do not try to move literals. To do it
9040 correctly might increase the number of relocations in an input
9041 section making the default relocatable linking fail. */
68ffbac6 9042 if (!link_info->relocatable && !literal_placed
43cd72b9
BW		 9043 && values->has_last_loc && !(*last_loc_is_prev_p))
9044 {
9045 asection *target_sec = r_reloc_get_section (&values->last_loc);
9046 if (target_sec && target_sec->output_section == sec->output_section)
9047 {
9048 /* Increment the virtual offset. */
9049 r_reloc try_loc = values->last_loc;
9050 try_loc.virtual_offset += 4;
9051
9052 /* There is a last loc that was in the same output section. */
9053 if (relocations_reach (rel, remaining_src_rels, &try_loc)
9054 && move_shared_literal (sec, link_info, rel,
68ffbac6 9055 prop_table, ptblsize,
43cd72b9 9056 &try_loc, &val, target_sec_cache))
e0001a05 9057 {
43cd72b9
BW		 9058 values->last_loc.virtual_offset += 4;
9059 literal_placed = TRUE;
9060 if (!val_map)
9061 val_map = add_value_map (values, &val, &try_loc,
9062 final_static_link);
9063 else
9064 val_map->loc = try_loc;
e0001a05
NC		 9065 }
9066 }
43cd72b9
BW		 9067 }
9068
9069 if (!literal_placed)
9070 {
9071 /* Nothing worked, leave the literal alone but update the last loc. */
9072 values->has_last_loc = TRUE;
9073 values->last_loc = rel->r_rel;
9074 if (!val_map)
9075 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
e0001a05 9076 else
43cd72b9
BW		 9077 val_map->loc = rel->r_rel;
9078 *last_loc_is_prev_p = TRUE;
e0001a05
NC		 9079 }
9080
43cd72b9 9081 return TRUE;
e0001a05
NC		 9082}
9083
9084
9085/* Check if the original relocations (presumably on L32R instructions)
9086 identified by reloc[0..N] can be changed to reference the literal
9087 identified by r_rel. If r_rel is out of range for any of the
9088 original relocations, then we don't want to coalesce the original
9089 literal with the one at r_rel. We only check reloc[0..N], where the
9090 offsets are all the same as for reloc[0] (i.e., they're all
9091 referencing the same literal) and where N is also bounded by the
9092 number of remaining entries in the "reloc" array. The "reloc" array
9093 is sorted by target offset so we know all the entries for the same
9094 literal will be contiguous. */
9095
9096static bfd_boolean
7fa3d080
BW		 9097relocations_reach (source_reloc *reloc,
9098 int remaining_relocs,
9099 const r_reloc *r_rel)
e0001a05
NC		 9100{
9101 bfd_vma from_offset, source_address, dest_address;
9102 asection *sec;
9103 int i;
9104
9105 if (!r_reloc_is_defined (r_rel))
9106 return FALSE;
9107
9108 sec = r_reloc_get_section (r_rel);
9109 from_offset = reloc[0].r_rel.target_offset;
9110
9111 for (i = 0; i < remaining_relocs; i++)
9112 {
9113 if (reloc[i].r_rel.target_offset != from_offset)
9114 break;
9115
9116 /* Ignore relocations that have been removed. */
9117 if (reloc[i].is_null)
9118 continue;
9119
9120 /* The original and new output section for these must be the same
9121 in order to coalesce. */
9122 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
9123 != sec->output_section)
9124 return FALSE;
9125
d638e0ac
BW		 9126 /* Absolute literals in the same output section can always be
9127 combined. */
9128 if (reloc[i].is_abs_literal)
9129 continue;
9130
43cd72b9
BW		 9131 /* A literal with no PC-relative relocations can be moved anywhere. */
9132 if (reloc[i].opnd != -1)
e0001a05
NC		 9133 {
9134 /* Otherwise, check to see that it fits. */
9135 source_address = (reloc[i].source_sec->output_section->vma
9136 + reloc[i].source_sec->output_offset
9137 + reloc[i].r_rel.rela.r_offset);
9138 dest_address = (sec->output_section->vma
9139 + sec->output_offset
9140 + r_rel->target_offset);
9141
43cd72b9
BW		 9142 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
9143 source_address, dest_address))
e0001a05
NC		 9144 return FALSE;
9145 }
9146 }
9147
9148 return TRUE;
9149}
9150
9151
43cd72b9
BW		 9152/* Move a literal to another literal location because it is
9153 the same as the other literal value. */
e0001a05 9154
68ffbac6 9155static bfd_boolean
7fa3d080
BW		 9156coalesce_shared_literal (asection *sec,
9157 source_reloc *rel,
9158 property_table_entry *prop_table,
9159 int ptblsize,
9160 value_map *val_map)
e0001a05 9161{
43cd72b9
BW		 9162 property_table_entry *entry;
9163 text_action *fa;
9164 property_table_entry *the_add_entry;
9165 int removed_diff;
9166 xtensa_relax_info *relax_info;
9167
9168 relax_info = get_xtensa_relax_info (sec);
9169 if (!relax_info)
9170 return FALSE;
9171
9172 entry = elf_xtensa_find_property_entry
9173 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
99ded152 9174 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
43cd72b9
BW		 9175 return TRUE;
9176
9177 /* Mark that the literal will be coalesced. */
9178 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
9179
9180 text_action_add (&relax_info->action_list,
9181 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9182
9183 /* If the section is 4-byte aligned, do not add fill. */
68ffbac6 9184 if (sec->alignment_power > 2)
e0001a05 9185 {
43cd72b9
BW		 9186 int fill_extra_space;
9187 bfd_vma entry_sec_offset;
9188
9189 if (entry)
9190 entry_sec_offset = entry->address - sec->vma + entry->size;
9191 else
9192 entry_sec_offset = rel->r_rel.target_offset + 4;
9193
9194 /* If the literal range is at the end of the section,
9195 do not add fill. */
9196 fill_extra_space = 0;
9197 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9198 entry_sec_offset);
9199 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9200 fill_extra_space = the_add_entry->size;
9201
9202 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9203 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9204 -4, fill_extra_space);
9205 if (fa)
9206 adjust_fill_action (fa, removed_diff);
9207 else
9208 text_action_add (&relax_info->action_list,
9209 ta_fill, sec, entry_sec_offset, removed_diff);
e0001a05 9210 }
43cd72b9
BW		 9211
9212 return TRUE;
9213}
9214
9215
9216/* Move a literal to another location. This may actually increase the
9217 total amount of space used because of alignments so we need to do
9218 this carefully. Also, it may make a branch go out of range. */
9219
68ffbac6 9220static bfd_boolean
7fa3d080
BW		 9221move_shared_literal (asection *sec,
9222 struct bfd_link_info *link_info,
9223 source_reloc *rel,
9224 property_table_entry *prop_table,
9225 int ptblsize,
9226 const r_reloc *target_loc,
9227 const literal_value *lit_value,
9228 section_cache_t *target_sec_cache)
43cd72b9
BW		 9229{
9230 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
9231 text_action *fa, *target_fa;
9232 int removed_diff;
9233 xtensa_relax_info *relax_info, *target_relax_info;
9234 asection *target_sec;
9235 ebb_t *ebb;
9236 ebb_constraint ebb_table;
9237 bfd_boolean relocs_fit;
9238
9239 /* If this routine always returns FALSE, the literals that cannot be
9240 coalesced will not be moved. */
9241 if (elf32xtensa_no_literal_movement)
9242 return FALSE;
9243
9244 relax_info = get_xtensa_relax_info (sec);
9245 if (!relax_info)
9246 return FALSE;
9247
9248 target_sec = r_reloc_get_section (target_loc);
9249 target_relax_info = get_xtensa_relax_info (target_sec);
9250
9251 /* Literals to undefined sections may not be moved because they
9252 must report an error. */
9253 if (bfd_is_und_section (target_sec))
9254 return FALSE;
9255
9256 src_entry = elf_xtensa_find_property_entry
9257 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9258
9259 if (!section_cache_section (target_sec_cache, target_sec, link_info))
9260 return FALSE;
9261
9262 target_entry = elf_xtensa_find_property_entry
68ffbac6 9263 (target_sec_cache->ptbl, target_sec_cache->pte_count,
43cd72b9
BW		 9264 target_sec->vma + target_loc->target_offset);
9265
9266 if (!target_entry)
9267 return FALSE;
9268
9269 /* Make sure that we have not broken any branches. */
9270 relocs_fit = FALSE;
9271
9272 init_ebb_constraint (&ebb_table);
9273 ebb = &ebb_table.ebb;
68ffbac6 9274 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
43cd72b9
BW		 9275 target_sec_cache->content_length,
9276 target_sec_cache->ptbl, target_sec_cache->pte_count,
9277 target_sec_cache->relocs, target_sec_cache->reloc_count);
9278
9279 /* Propose to add 4 bytes + worst-case alignment size increase to
9280 destination. */
9281 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
9282 ta_fill, target_loc->target_offset,
9283 -4 - (1 << target_sec->alignment_power), TRUE);
9284
9285 /* Check all of the PC-relative relocations to make sure they still fit. */
68ffbac6 9286 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
43cd72b9 9287 target_sec_cache->contents,
b2b326d2 9288 target_sec_cache->relocs, NULL,
cb337148 9289 &ebb_table, NULL);
43cd72b9 9290
68ffbac6 9291 if (!relocs_fit)
43cd72b9
BW		 9292 return FALSE;
9293
9294 text_action_add_literal (&target_relax_info->action_list,
9295 ta_add_literal, target_loc, lit_value, -4);
9296
68ffbac6 9297 if (target_sec->alignment_power > 2 && target_entry != src_entry)
43cd72b9
BW		 9298 {
9299 /* May need to add or remove some fill to maintain alignment. */
9300 int fill_extra_space;
9301 bfd_vma entry_sec_offset;
9302
68ffbac6 9303 entry_sec_offset =
43cd72b9
BW		 9304 target_entry->address - target_sec->vma + target_entry->size;
9305
9306 /* If the literal range is at the end of the section,
9307 do not add fill. */
9308 fill_extra_space = 0;
9309 the_add_entry =
9310 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
9311 target_sec_cache->pte_count,
9312 entry_sec_offset);
9313 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9314 fill_extra_space = the_add_entry->size;
9315
9316 target_fa = find_fill_action (&target_relax_info->action_list,
9317 target_sec, entry_sec_offset);
9318 removed_diff = compute_removed_action_diff (target_fa, target_sec,
9319 entry_sec_offset, 4,
9320 fill_extra_space);
9321 if (target_fa)
9322 adjust_fill_action (target_fa, removed_diff);
9323 else
9324 text_action_add (&target_relax_info->action_list,
9325 ta_fill, target_sec, entry_sec_offset, removed_diff);
9326 }
9327
9328 /* Mark that the literal will be moved to the new location. */
9329 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
9330
9331 /* Remove the literal. */
9332 text_action_add (&relax_info->action_list,
9333 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9334
9335 /* If the section is 4-byte aligned, do not add fill. */
68ffbac6 9336 if (sec->alignment_power > 2 && target_entry != src_entry)
43cd72b9
BW		 9337 {
9338 int fill_extra_space;
9339 bfd_vma entry_sec_offset;
9340
9341 if (src_entry)
9342 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
9343 else
9344 entry_sec_offset = rel->r_rel.target_offset+4;
9345
9346 /* If the literal range is at the end of the section,
9347 do not add fill. */
9348 fill_extra_space = 0;
9349 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9350 entry_sec_offset);
9351 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9352 fill_extra_space = the_add_entry->size;
9353
9354 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9355 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9356 -4, fill_extra_space);
9357 if (fa)
9358 adjust_fill_action (fa, removed_diff);
9359 else
9360 text_action_add (&relax_info->action_list,
9361 ta_fill, sec, entry_sec_offset, removed_diff);
9362 }
9363
9364 return TRUE;
e0001a05
NC		 9365}
9366
9367\f
9368/* Second relaxation pass. */
9369
4c2af04f
MF		 9370static int
9371action_remove_bytes_fn (splay_tree_node node, void *p)
9372{
9373 bfd_size_type *final_size = p;
9374 text_action *action = (text_action *)node->value;
9375
9376 *final_size -= action->removed_bytes;
9377 return 0;
9378}
9379
e0001a05
NC		 9380/* Modify all of the relocations to point to the right spot, and if this
9381 is a relaxable section, delete the unwanted literals and fix the
43cd72b9 9382 section size. */
e0001a05 9383
43cd72b9 9384bfd_boolean
7fa3d080 9385relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
e0001a05
NC		 9386{
9387 Elf_Internal_Rela *internal_relocs;
9388 xtensa_relax_info *relax_info;
9389 bfd_byte *contents;
9390 bfd_boolean ok = TRUE;
9391 unsigned i;
43cd72b9
BW		 9392 bfd_boolean rv = FALSE;
9393 bfd_boolean virtual_action;
9394 bfd_size_type sec_size;
e0001a05 9395
43cd72b9 9396 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 9397 relax_info = get_xtensa_relax_info (sec);
9398 BFD_ASSERT (relax_info);
9399
43cd72b9
BW		 9400 /* First translate any of the fixes that have been added already. */
9401 translate_section_fixes (sec);
9402
e0001a05
NC		 9403 /* Handle property sections (e.g., literal tables) specially. */
9404 if (xtensa_is_property_section (sec))
9405 {
9406 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
9407 return relax_property_section (abfd, sec, link_info);
9408 }
9409
68ffbac6 9410 internal_relocs = retrieve_internal_relocs (abfd, sec,
43cd72b9 9411 link_info->keep_memory);
4c2af04f 9412 if (!internal_relocs && !action_list_count (&relax_info->action_list))
7aa09196
SA		 9413 return TRUE;
9414
43cd72b9
BW		 9415 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9416 if (contents == NULL && sec_size != 0)
9417 {
9418 ok = FALSE;
9419 goto error_return;
9420 }
9421
9422 if (internal_relocs)
9423 {
9424 for (i = 0; i < sec->reloc_count; i++)
9425 {
9426 Elf_Internal_Rela *irel;
9427 xtensa_relax_info *target_relax_info;
9428 bfd_vma source_offset, old_source_offset;
9429 r_reloc r_rel;
9430 unsigned r_type;
9431 asection *target_sec;
9432
9433 /* Locally change the source address.
9434 Translate the target to the new target address.
9435 If it points to this section and has been removed,
9436 NULLify it.
9437 Write it back. */
9438
9439 irel = &internal_relocs[i];
9440 source_offset = irel->r_offset;
9441 old_source_offset = source_offset;
9442
9443 r_type = ELF32_R_TYPE (irel->r_info);
9444 r_reloc_init (&r_rel, abfd, irel, contents,
9445 bfd_get_section_limit (abfd, sec));
9446
9447 /* If this section could have changed then we may need to
9448 change the relocation's offset. */
9449
9450 if (relax_info->is_relaxable_literal_section
9451 || relax_info->is_relaxable_asm_section)
9452 {
9b7f5d20
BW		 9453 pin_internal_relocs (sec, internal_relocs);
9454
43cd72b9
BW		 9455 if (r_type != R_XTENSA_NONE
9456 && find_removed_literal (&relax_info->removed_list,
9457 irel->r_offset))
9458 {
9459 /* Remove this relocation. */
9460 if (elf_hash_table (link_info)->dynamic_sections_created)
9461 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
9462 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
071aa5c9 9463 irel->r_offset = offset_with_removed_text_map
43cd72b9 9464 (&relax_info->action_list, irel->r_offset);
43cd72b9
BW		 9465 continue;
9466 }
9467
9468 if (r_type == R_XTENSA_ASM_SIMPLIFY)
9469 {
9470 text_action *action =
9471 find_insn_action (&relax_info->action_list,
9472 irel->r_offset);
9473 if (action && (action->action == ta_convert_longcall
9474 || action->action == ta_remove_longcall))
9475 {
9476 bfd_reloc_status_type retval;
9477 char *error_message = NULL;
9478
9479 retval = contract_asm_expansion (contents, sec_size,
9480 irel, &error_message);
9481 if (retval != bfd_reloc_ok)
9482 {
9483 (*link_info->callbacks->reloc_dangerous)
9484 (link_info, error_message, abfd, sec,
9485 irel->r_offset);
9486 goto error_return;
9487 }
9488 /* Update the action so that the code that moves
9489 the contents will do the right thing. */
4c2af04f
MF		 9490 /* ta_remove_longcall and ta_remove_insn actions are
9491 grouped together in the tree as well as
9492 ta_convert_longcall and ta_none, so that changes below
9493 can be done w/o removing and reinserting action into
9494 the tree. */
9495
43cd72b9
BW		 9496 if (action->action == ta_remove_longcall)
9497 action->action = ta_remove_insn;
9498 else
9499 action->action = ta_none;
9500 /* Refresh the info in the r_rel. */
9501 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9502 r_type = ELF32_R_TYPE (irel->r_info);
9503 }
9504 }
9505
071aa5c9 9506 source_offset = offset_with_removed_text_map
43cd72b9
BW		 9507 (&relax_info->action_list, irel->r_offset);
9508 irel->r_offset = source_offset;
9509 }
9510
9511 /* If the target section could have changed then
9512 we may need to change the relocation's target offset. */
9513
9514 target_sec = r_reloc_get_section (&r_rel);
43cd72b9 9515
ae326da8
BW		 9516 /* For a reference to a discarded section from a DWARF section,
9517 i.e., where action_discarded is PRETEND, the symbol will
9518 eventually be modified to refer to the kept section (at least if
9519 the kept and discarded sections are the same size). Anticipate
9520 that here and adjust things accordingly. */
9521 if (! elf_xtensa_ignore_discarded_relocs (sec)
9522 && elf_xtensa_action_discarded (sec) == PRETEND
dbaa2011 9523 && sec->sec_info_type != SEC_INFO_TYPE_STABS
ae326da8 9524 && target_sec != NULL
dbaa2011 9525 && discarded_section (target_sec))
ae326da8
BW		 9526 {
9527 /* It would be natural to call _bfd_elf_check_kept_section
9528 here, but it's not exported from elflink.c. It's also a
9529 fairly expensive check. Adjusting the relocations to the
9530 discarded section is fairly harmless; it will only adjust
9531 some addends and difference values. If it turns out that
9532 _bfd_elf_check_kept_section fails later, it won't matter,
9533 so just compare the section names to find the right group
9534 member. */
9535 asection *kept = target_sec->kept_section;
9536 if (kept != NULL)
9537 {
9538 if ((kept->flags & SEC_GROUP) != 0)
9539 {
9540 asection *first = elf_next_in_group (kept);
9541 asection *s = first;
9542
9543 kept = NULL;
9544 while (s != NULL)
9545 {
9546 if (strcmp (s->name, target_sec->name) == 0)
9547 {
9548 kept = s;
9549 break;
9550 }
9551 s = elf_next_in_group (s);
9552 if (s == first)
9553 break;
9554 }
9555 }
9556 }
9557 if (kept != NULL
9558 && ((target_sec->rawsize != 0
9559 ? target_sec->rawsize : target_sec->size)
9560 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9561 target_sec = kept;
9562 }
9563
9564 target_relax_info = get_xtensa_relax_info (target_sec);
43cd72b9
BW		 9565 if (target_relax_info
9566 && (target_relax_info->is_relaxable_literal_section
9567 || target_relax_info->is_relaxable_asm_section))
9568 {
9569 r_reloc new_reloc;
9b7f5d20 9570 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
43cd72b9
BW		 9571
9572 if (r_type == R_XTENSA_DIFF8
9573 || r_type == R_XTENSA_DIFF16
9574 || r_type == R_XTENSA_DIFF32)
9575 {
1058c753
VA		 9576 bfd_signed_vma diff_value = 0;
9577 bfd_vma new_end_offset, diff_mask = 0;
43cd72b9
BW		 9578
9579 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9580 {
9581 (*link_info->callbacks->reloc_dangerous)
9582 (link_info, _("invalid relocation address"),
9583 abfd, sec, old_source_offset);
9584 goto error_return;
9585 }
9586
9587 switch (r_type)
9588 {
9589 case R_XTENSA_DIFF8:
9590 diff_value =
1058c753 9591 bfd_get_signed_8 (abfd, &contents[old_source_offset]);
43cd72b9
BW		 9592 break;
9593 case R_XTENSA_DIFF16:
9594 diff_value =
1058c753 9595 bfd_get_signed_16 (abfd, &contents[old_source_offset]);
43cd72b9
BW		 9596 break;
9597 case R_XTENSA_DIFF32:
9598 diff_value =
1058c753 9599 bfd_get_signed_32 (abfd, &contents[old_source_offset]);
43cd72b9
BW		 9600 break;
9601 }
9602
071aa5c9 9603 new_end_offset = offset_with_removed_text_map
43cd72b9
BW		 9604 (&target_relax_info->action_list,
9605 r_rel.target_offset + diff_value);
9606 diff_value = new_end_offset - new_reloc.target_offset;
9607
9608 switch (r_type)
9609 {
9610 case R_XTENSA_DIFF8:
1058c753
VA		 9611 diff_mask = 0x7f;
9612 bfd_put_signed_8 (abfd, diff_value,
43cd72b9
BW		 9613 &contents[old_source_offset]);
9614 break;
9615 case R_XTENSA_DIFF16:
1058c753
VA		 9616 diff_mask = 0x7fff;
9617 bfd_put_signed_16 (abfd, diff_value,
43cd72b9
BW		 9618 &contents[old_source_offset]);
9619 break;
9620 case R_XTENSA_DIFF32:
1058c753
VA		 9621 diff_mask = 0x7fffffff;
9622 bfd_put_signed_32 (abfd, diff_value,
43cd72b9
BW		 9623 &contents[old_source_offset]);
9624 break;
9625 }
9626
1058c753
VA		 9627 /* Check for overflow. Sign bits must be all zeroes or all ones */
9628 if ((diff_value & ~diff_mask) != 0 &&
9629 (diff_value & ~diff_mask) != (-1 & ~diff_mask))
43cd72b9
BW		 9630 {
9631 (*link_info->callbacks->reloc_dangerous)
9632 (link_info, _("overflow after relaxation"),
9633 abfd, sec, old_source_offset);
9634 goto error_return;
9635 }
9636
9637 pin_contents (sec, contents);
9638 }
dc96b90a
BW		 9639
9640 /* If the relocation still references a section in the same
9641 input file, modify the relocation directly instead of
9642 adding a "fix" record. */
9643 if (target_sec->owner == abfd)
9644 {
9645 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9646 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9647 irel->r_addend = new_reloc.rela.r_addend;
9648 pin_internal_relocs (sec, internal_relocs);
9649 }
9b7f5d20
BW		 9650 else
9651 {
dc96b90a
BW		 9652 bfd_vma addend_displacement;
9653 reloc_bfd_fix *fix;
9654
9655 addend_displacement =
9656 new_reloc.target_offset + new_reloc.virtual_offset;
9657 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9658 target_sec,
9659 addend_displacement, TRUE);
9660 add_fix (sec, fix);
9b7f5d20 9661 }
43cd72b9 9662 }
43cd72b9
BW		 9663 }
9664 }
9665
9666 if ((relax_info->is_relaxable_literal_section
9667 || relax_info->is_relaxable_asm_section)
4c2af04f 9668 && action_list_count (&relax_info->action_list))
43cd72b9
BW		 9669 {
9670 /* Walk through the planned actions and build up a table
9671 of move, copy and fill records. Use the move, copy and
9672 fill records to perform the actions once. */
9673
43cd72b9
BW		 9674 bfd_size_type final_size, copy_size, orig_insn_size;
9675 bfd_byte *scratch = NULL;
9676 bfd_byte *dup_contents = NULL;
a3ef2d63 9677 bfd_size_type orig_size = sec->size;
43cd72b9
BW		 9678 bfd_vma orig_dot = 0;
9679 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9680 orig dot in physical memory. */
9681 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9682 bfd_vma dup_dot = 0;
9683
4c2af04f 9684 text_action *action;
43cd72b9
BW		 9685
9686 final_size = sec->size;
43cd72b9 9687
4c2af04f
MF		 9688 splay_tree_foreach (relax_info->action_list.tree,
9689 action_remove_bytes_fn, &final_size);
43cd72b9
BW		 9690 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9691 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9692
9693 /* The dot is the current fill location. */
9694#if DEBUG
9695 print_action_list (stderr, &relax_info->action_list);
9696#endif
9697
4c2af04f
MF		 9698 for (action = action_first (&relax_info->action_list); action;
9699 action = action_next (&relax_info->action_list, action))
43cd72b9
BW		 9700 {
9701 virtual_action = FALSE;
9702 if (action->offset > orig_dot)
9703 {
9704 orig_dot += orig_dot_copied;
9705 orig_dot_copied = 0;
9706 orig_dot_vo = 0;
9707 /* Out of the virtual world. */
9708 }
9709
9710 if (action->offset > orig_dot)
9711 {
9712 copy_size = action->offset - orig_dot;
9713 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9714 orig_dot += copy_size;
9715 dup_dot += copy_size;
9716 BFD_ASSERT (action->offset == orig_dot);
9717 }
9718 else if (action->offset < orig_dot)
9719 {
9720 if (action->action == ta_fill
9721 && action->offset - action->removed_bytes == orig_dot)
9722 {
9723 /* This is OK because the fill only effects the dup_dot. */
9724 }
9725 else if (action->action == ta_add_literal)
9726 {
9727 /* TBD. Might need to handle this. */
9728 }
9729 }
9730 if (action->offset == orig_dot)
9731 {
9732 if (action->virtual_offset > orig_dot_vo)
9733 {
9734 if (orig_dot_vo == 0)
9735 {
9736 /* Need to copy virtual_offset bytes. Probably four. */
9737 copy_size = action->virtual_offset - orig_dot_vo;
9738 memmove (&dup_contents[dup_dot],
9739 &contents[orig_dot], copy_size);
9740 orig_dot_copied = copy_size;
9741 dup_dot += copy_size;
9742 }
9743 virtual_action = TRUE;
68ffbac6 9744 }
43cd72b9
BW		 9745 else
9746 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9747 }
9748 switch (action->action)
9749 {
9750 case ta_remove_literal:
9751 case ta_remove_insn:
9752 BFD_ASSERT (action->removed_bytes >= 0);
9753 orig_dot += action->removed_bytes;
9754 break;
9755
9756 case ta_narrow_insn:
9757 orig_insn_size = 3;
9758 copy_size = 2;
9759 memmove (scratch, &contents[orig_dot], orig_insn_size);
9760 BFD_ASSERT (action->removed_bytes == 1);
64b607e6 9761 rv = narrow_instruction (scratch, final_size, 0);
43cd72b9
BW		 9762 BFD_ASSERT (rv);
9763 memmove (&dup_contents[dup_dot], scratch, copy_size);
9764 orig_dot += orig_insn_size;
9765 dup_dot += copy_size;
9766 break;
9767
9768 case ta_fill:
9769 if (action->removed_bytes >= 0)
9770 orig_dot += action->removed_bytes;
9771 else
9772 {
9773 /* Already zeroed in dup_contents. Just bump the
9774 counters. */
9775 dup_dot += (-action->removed_bytes);
9776 }
9777 break;
9778
9779 case ta_none:
9780 BFD_ASSERT (action->removed_bytes == 0);
9781 break;
9782
9783 case ta_convert_longcall:
9784 case ta_remove_longcall:
9785 /* These will be removed or converted before we get here. */
9786 BFD_ASSERT (0);
9787 break;
9788
9789 case ta_widen_insn:
9790 orig_insn_size = 2;
9791 copy_size = 3;
9792 memmove (scratch, &contents[orig_dot], orig_insn_size);
9793 BFD_ASSERT (action->removed_bytes == -1);
64b607e6 9794 rv = widen_instruction (scratch, final_size, 0);
43cd72b9
BW		 9795 BFD_ASSERT (rv);
9796 memmove (&dup_contents[dup_dot], scratch, copy_size);
9797 orig_dot += orig_insn_size;
9798 dup_dot += copy_size;
9799 break;
9800
9801 case ta_add_literal:
9802 orig_insn_size = 0;
9803 copy_size = 4;
9804 BFD_ASSERT (action->removed_bytes == -4);
9805 /* TBD -- place the literal value here and insert
9806 into the table. */
9807 memset (&dup_contents[dup_dot], 0, 4);
9808 pin_internal_relocs (sec, internal_relocs);
9809 pin_contents (sec, contents);
9810
9811 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9812 relax_info, &internal_relocs, &action->value))
9813 goto error_return;
9814
68ffbac6 9815 if (virtual_action)
43cd72b9
BW		 9816 orig_dot_vo += copy_size;
9817
9818 orig_dot += orig_insn_size;
9819 dup_dot += copy_size;
9820 break;
9821
9822 default:
9823 /* Not implemented yet. */
9824 BFD_ASSERT (0);
9825 break;
9826 }
9827
43cd72b9
BW		 9828 BFD_ASSERT (dup_dot <= final_size);
9829 BFD_ASSERT (orig_dot <= orig_size);
9830 }
9831
9832 orig_dot += orig_dot_copied;
9833 orig_dot_copied = 0;
9834
9835 if (orig_dot != orig_size)
9836 {
9837 copy_size = orig_size - orig_dot;
9838 BFD_ASSERT (orig_size > orig_dot);
9839 BFD_ASSERT (dup_dot + copy_size == final_size);
9840 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9841 orig_dot += copy_size;
9842 dup_dot += copy_size;
9843 }
9844 BFD_ASSERT (orig_size == orig_dot);
9845 BFD_ASSERT (final_size == dup_dot);
9846
9847 /* Move the dup_contents back. */
9848 if (final_size > orig_size)
9849 {
9850 /* Contents need to be reallocated. Swap the dup_contents into
9851 contents. */
9852 sec->contents = dup_contents;
9853 free (contents);
9854 contents = dup_contents;
9855 pin_contents (sec, contents);
9856 }
9857 else
9858 {
9859 BFD_ASSERT (final_size <= orig_size);
9860 memset (contents, 0, orig_size);
9861 memcpy (contents, dup_contents, final_size);
9862 free (dup_contents);
9863 }
9864 free (scratch);
9865 pin_contents (sec, contents);
9866
a3ef2d63
BW		 9867 if (sec->rawsize == 0)
9868 sec->rawsize = sec->size;
43cd72b9
BW		 9869 sec->size = final_size;
9870 }
9871
9872 error_return:
9873 release_internal_relocs (sec, internal_relocs);
9874 release_contents (sec, contents);
9875 return ok;
9876}
9877
9878
68ffbac6 9879static bfd_boolean
7fa3d080 9880translate_section_fixes (asection *sec)
43cd72b9
BW		 9881{
9882 xtensa_relax_info *relax_info;
9883 reloc_bfd_fix *r;
9884
9885 relax_info = get_xtensa_relax_info (sec);
9886 if (!relax_info)
9887 return TRUE;
9888
9889 for (r = relax_info->fix_list; r != NULL; r = r->next)
9890 if (!translate_reloc_bfd_fix (r))
9891 return FALSE;
e0001a05 9892
43cd72b9
BW		 9893 return TRUE;
9894}
e0001a05 9895
e0001a05 9896
43cd72b9
BW		 9897/* Translate a fix given the mapping in the relax info for the target
9898 section. If it has already been translated, no work is required. */
e0001a05 9899
68ffbac6 9900static bfd_boolean
7fa3d080 9901translate_reloc_bfd_fix (reloc_bfd_fix *fix)
43cd72b9
BW		 9902{
9903 reloc_bfd_fix new_fix;
9904 asection *sec;
9905 xtensa_relax_info *relax_info;
9906 removed_literal *removed;
9907 bfd_vma new_offset, target_offset;
e0001a05 9908
43cd72b9
BW		 9909 if (fix->translated)
9910 return TRUE;
e0001a05 9911
43cd72b9
BW		 9912 sec = fix->target_sec;
9913 target_offset = fix->target_offset;
e0001a05 9914
43cd72b9
BW		 9915 relax_info = get_xtensa_relax_info (sec);
9916 if (!relax_info)
9917 {
9918 fix->translated = TRUE;
9919 return TRUE;
9920 }
e0001a05 9921
43cd72b9 9922 new_fix = *fix;
e0001a05 9923
43cd72b9
BW		 9924 /* The fix does not need to be translated if the section cannot change. */
9925 if (!relax_info->is_relaxable_literal_section
9926 && !relax_info->is_relaxable_asm_section)
9927 {
9928 fix->translated = TRUE;
9929 return TRUE;
9930 }
e0001a05 9931
43cd72b9
BW		 9932 /* If the literal has been moved and this relocation was on an
9933 opcode, then the relocation should move to the new literal
9934 location. Otherwise, the relocation should move within the
9935 section. */
9936
9937 removed = FALSE;
9938 if (is_operand_relocation (fix->src_type))
9939 {
9940 /* Check if the original relocation is against a literal being
9941 removed. */
9942 removed = find_removed_literal (&relax_info->removed_list,
9943 target_offset);
e0001a05
NC		 9944 }
9945
68ffbac6 9946 if (removed)
e0001a05 9947 {
43cd72b9 9948 asection *new_sec;
e0001a05 9949
43cd72b9
BW		 9950 /* The fact that there is still a relocation to this literal indicates
9951 that the literal is being coalesced, not simply removed. */
9952 BFD_ASSERT (removed->to.abfd != NULL);
e0001a05 9953
43cd72b9
BW		 9954 /* This was moved to some other address (possibly another section). */
9955 new_sec = r_reloc_get_section (&removed->to);
68ffbac6 9956 if (new_sec != sec)
e0001a05 9957 {
43cd72b9
BW		 9958 sec = new_sec;
9959 relax_info = get_xtensa_relax_info (sec);
68ffbac6 9960 if (!relax_info ||
43cd72b9
BW		 9961 (!relax_info->is_relaxable_literal_section
9962 && !relax_info->is_relaxable_asm_section))
e0001a05 9963 {
43cd72b9
BW		 9964 target_offset = removed->to.target_offset;
9965 new_fix.target_sec = new_sec;
9966 new_fix.target_offset = target_offset;
9967 new_fix.translated = TRUE;
9968 *fix = new_fix;
9969 return TRUE;
e0001a05 9970 }
e0001a05 9971 }
43cd72b9
BW		 9972 target_offset = removed->to.target_offset;
9973 new_fix.target_sec = new_sec;
e0001a05 9974 }
43cd72b9
BW		 9975
9976 /* The target address may have been moved within its section. */
9977 new_offset = offset_with_removed_text (&relax_info->action_list,
9978 target_offset);
9979
9980 new_fix.target_offset = new_offset;
9981 new_fix.target_offset = new_offset;
9982 new_fix.translated = TRUE;
9983 *fix = new_fix;
9984 return TRUE;
e0001a05
NC		 9985}
9986
9987
9988/* Fix up a relocation to take account of removed literals. */
9989
9b7f5d20
BW		 9990static asection *
9991translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
e0001a05 9992{
e0001a05
NC		 9993 xtensa_relax_info *relax_info;
9994 removed_literal *removed;
9b7f5d20 9995 bfd_vma target_offset, base_offset;
e0001a05
NC		 9996
9997 *new_rel = *orig_rel;
9998
9999 if (!r_reloc_is_defined (orig_rel))
9b7f5d20 10000 return sec ;
e0001a05
NC		 10001
10002 relax_info = get_xtensa_relax_info (sec);
9b7f5d20
BW		 10003 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
10004 || relax_info->is_relaxable_asm_section));
e0001a05 10005
43cd72b9
BW		 10006 target_offset = orig_rel->target_offset;
10007
10008 removed = FALSE;
10009 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
10010 {
10011 /* Check if the original relocation is against a literal being
10012 removed. */
10013 removed = find_removed_literal (&relax_info->removed_list,
10014 target_offset);
10015 }
10016 if (removed && removed->to.abfd)
e0001a05
NC		 10017 {
10018 asection *new_sec;
10019
10020 /* The fact that there is still a relocation to this literal indicates
10021 that the literal is being coalesced, not simply removed. */
10022 BFD_ASSERT (removed->to.abfd != NULL);
10023
43cd72b9
BW		 10024 /* This was moved to some other address
10025 (possibly in another section). */
e0001a05
NC		 10026 *new_rel = removed->to;
10027 new_sec = r_reloc_get_section (new_rel);
43cd72b9 10028 if (new_sec != sec)
e0001a05
NC		 10029 {
10030 sec = new_sec;
10031 relax_info = get_xtensa_relax_info (sec);
43cd72b9
BW		 10032 if (!relax_info
10033 || (!relax_info->is_relaxable_literal_section
10034 && !relax_info->is_relaxable_asm_section))
9b7f5d20 10035 return sec;
e0001a05 10036 }
43cd72b9 10037 target_offset = new_rel->target_offset;
e0001a05
NC		 10038 }
10039
9b7f5d20
BW		 10040 /* Find the base offset of the reloc symbol, excluding any addend from the
10041 reloc or from the section contents (for a partial_inplace reloc). Then
10042 find the adjusted values of the offsets due to relaxation. The base
10043 offset is needed to determine the change to the reloc's addend; the reloc
10044 addend should not be adjusted due to relaxations located before the base
10045 offset. */
10046
10047 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9b7f5d20
BW		 10048 if (base_offset <= target_offset)
10049 {
071aa5c9
MF		 10050 int base_removed = removed_by_actions_map (&relax_info->action_list,
10051 base_offset, FALSE);
10052 int addend_removed = removed_by_actions_map (&relax_info->action_list,
10053 target_offset, FALSE) -
10054 base_removed;
10055
9b7f5d20
BW		 10056 new_rel->target_offset = target_offset - base_removed - addend_removed;
10057 new_rel->rela.r_addend -= addend_removed;
10058 }
10059 else
10060 {
10061 /* Handle a negative addend. The base offset comes first. */
071aa5c9
MF		 10062 int tgt_removed = removed_by_actions_map (&relax_info->action_list,
10063 target_offset, FALSE);
10064 int addend_removed = removed_by_actions_map (&relax_info->action_list,
10065 base_offset, FALSE) -
10066 tgt_removed;
10067
9b7f5d20
BW		 10068 new_rel->target_offset = target_offset - tgt_removed;
10069 new_rel->rela.r_addend += addend_removed;
10070 }
e0001a05 10071
9b7f5d20 10072 return sec;
e0001a05
NC		 10073}
10074
10075
10076/* For dynamic links, there may be a dynamic relocation for each
10077 literal. The number of dynamic relocations must be computed in
10078 size_dynamic_sections, which occurs before relaxation. When a
10079 literal is removed, this function checks if there is a corresponding
10080 dynamic relocation and shrinks the size of the appropriate dynamic
10081 relocation section accordingly. At this point, the contents of the
10082 dynamic relocation sections have not yet been filled in, so there's
10083 nothing else that needs to be done. */
10084
10085static void
7fa3d080
BW		 10086shrink_dynamic_reloc_sections (struct bfd_link_info *info,
10087 bfd *abfd,
10088 asection *input_section,
10089 Elf_Internal_Rela *rel)
e0001a05 10090{
f0e6fdb2 10091 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 10092 Elf_Internal_Shdr *symtab_hdr;
10093 struct elf_link_hash_entry **sym_hashes;
10094 unsigned long r_symndx;
10095 int r_type;
10096 struct elf_link_hash_entry *h;
10097 bfd_boolean dynamic_symbol;
10098
f0e6fdb2 10099 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 10100 if (htab == NULL)
10101 return;
10102
e0001a05
NC		 10103 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10104 sym_hashes = elf_sym_hashes (abfd);
10105
10106 r_type = ELF32_R_TYPE (rel->r_info);
10107 r_symndx = ELF32_R_SYM (rel->r_info);
10108
10109 if (r_symndx < symtab_hdr->sh_info)
10110 h = NULL;
10111 else
10112 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10113
4608f3d9 10114 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
e0001a05
NC		 10115
10116 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
10117 && (input_section->flags & SEC_ALLOC) != 0
10118 && (dynamic_symbol || info->shared))
10119 {
e0001a05
NC		 10120 asection *srel;
10121 bfd_boolean is_plt = FALSE;
10122
e0001a05
NC		 10123 if (dynamic_symbol && r_type == R_XTENSA_PLT)
10124 {
f0e6fdb2 10125 srel = htab->srelplt;
e0001a05
NC		 10126 is_plt = TRUE;
10127 }
10128 else
f0e6fdb2 10129 srel = htab->srelgot;
e0001a05
NC		 10130
10131 /* Reduce size of the .rela.* section by one reloc. */
e0001a05 10132 BFD_ASSERT (srel != NULL);
eea6121a
AM		 10133 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
10134 srel->size -= sizeof (Elf32_External_Rela);
e0001a05
NC		 10135
10136 if (is_plt)
10137 {
10138 asection *splt, *sgotplt, *srelgot;
10139 int reloc_index, chunk;
10140
10141 /* Find the PLT reloc index of the entry being removed. This
10142 is computed from the size of ".rela.plt". It is needed to
10143 figure out which PLT chunk to resize. Usually "last index
10144 = size - 1" since the index starts at zero, but in this
10145 context, the size has just been decremented so there's no
10146 need to subtract one. */
eea6121a 10147 reloc_index = srel->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 10148
10149 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
f0e6fdb2
BW		 10150 splt = elf_xtensa_get_plt_section (info, chunk);
10151 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 10152 BFD_ASSERT (splt != NULL && sgotplt != NULL);
10153
10154 /* Check if an entire PLT chunk has just been eliminated. */
10155 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
10156 {
10157 /* The two magic GOT entries for that chunk can go away. */
f0e6fdb2 10158 srelgot = htab->srelgot;
e0001a05
NC		 10159 BFD_ASSERT (srelgot != NULL);
10160 srelgot->reloc_count -= 2;
eea6121a
AM		 10161 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
10162 sgotplt->size -= 8;
e0001a05
NC		 10163
10164 /* There should be only one entry left (and it will be
10165 removed below). */
eea6121a
AM		 10166 BFD_ASSERT (sgotplt->size == 4);
10167 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
e0001a05
NC		 10168 }
10169
eea6121a
AM		 10170 BFD_ASSERT (sgotplt->size >= 4);
10171 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
e0001a05 10172
eea6121a
AM		 10173 sgotplt->size -= 4;
10174 splt->size -= PLT_ENTRY_SIZE;
e0001a05
NC		 10175 }
10176 }
10177}
10178
10179
43cd72b9
BW		 10180/* Take an r_rel and move it to another section. This usually
10181 requires extending the interal_relocation array and pinning it. If
10182 the original r_rel is from the same BFD, we can complete this here.
10183 Otherwise, we add a fix record to let the final link fix the
10184 appropriate address. Contents and internal relocations for the
10185 section must be pinned after calling this routine. */
10186
10187static bfd_boolean
7fa3d080
BW		 10188move_literal (bfd *abfd,
10189 struct bfd_link_info *link_info,
10190 asection *sec,
10191 bfd_vma offset,
10192 bfd_byte *contents,
10193 xtensa_relax_info *relax_info,
10194 Elf_Internal_Rela **internal_relocs_p,
10195 const literal_value *lit)
43cd72b9
BW		 10196{
10197 Elf_Internal_Rela *new_relocs = NULL;
10198 size_t new_relocs_count = 0;
10199 Elf_Internal_Rela this_rela;
10200 const r_reloc *r_rel;
10201
10202 r_rel = &lit->r_rel;
10203 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
10204
10205 if (r_reloc_is_const (r_rel))
10206 bfd_put_32 (abfd, lit->value, contents + offset);
10207 else
10208 {
10209 int r_type;
10210 unsigned i;
43cd72b9
BW		 10211 reloc_bfd_fix *fix;
10212 unsigned insert_at;
10213
10214 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
43cd72b9
BW		 10215
10216 /* This is the difficult case. We have to create a fix up. */
10217 this_rela.r_offset = offset;
10218 this_rela.r_info = ELF32_R_INFO (0, r_type);
10219 this_rela.r_addend =
10220 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
10221 bfd_put_32 (abfd, lit->value, contents + offset);
10222
10223 /* Currently, we cannot move relocations during a relocatable link. */
10224 BFD_ASSERT (!link_info->relocatable);
0f5f1638 10225 fix = reloc_bfd_fix_init (sec, offset, r_type,
43cd72b9
BW		 10226 r_reloc_get_section (r_rel),
10227 r_rel->target_offset + r_rel->virtual_offset,
10228 FALSE);
10229 /* We also need to mark that relocations are needed here. */
10230 sec->flags |= SEC_RELOC;
10231
10232 translate_reloc_bfd_fix (fix);
10233 /* This fix has not yet been translated. */
10234 add_fix (sec, fix);
10235
10236 /* Add the relocation. If we have already allocated our own
10237 space for the relocations and we have room for more, then use
10238 it. Otherwise, allocate new space and move the literals. */
10239 insert_at = sec->reloc_count;
10240 for (i = 0; i < sec->reloc_count; ++i)
10241 {
10242 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
10243 {
10244 insert_at = i;
10245 break;
10246 }
10247 }
10248
10249 if (*internal_relocs_p != relax_info->allocated_relocs
10250 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
10251 {
10252 BFD_ASSERT (relax_info->allocated_relocs == NULL
10253 || sec->reloc_count == relax_info->relocs_count);
10254
68ffbac6 10255 if (relax_info->allocated_relocs_count == 0)
43cd72b9
BW		 10256 new_relocs_count = (sec->reloc_count + 2) * 2;
10257 else
10258 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
10259
10260 new_relocs = (Elf_Internal_Rela *)
10261 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
10262 if (!new_relocs)
10263 return FALSE;
10264
10265 /* We could handle this more quickly by finding the split point. */
10266 if (insert_at != 0)
10267 memcpy (new_relocs, *internal_relocs_p,
10268 insert_at * sizeof (Elf_Internal_Rela));
10269
10270 new_relocs[insert_at] = this_rela;
10271
10272 if (insert_at != sec->reloc_count)
10273 memcpy (new_relocs + insert_at + 1,
10274 (*internal_relocs_p) + insert_at,
68ffbac6 10275 (sec->reloc_count - insert_at)
43cd72b9
BW		 10276 * sizeof (Elf_Internal_Rela));
10277
10278 if (*internal_relocs_p != relax_info->allocated_relocs)
10279 {
10280 /* The first time we re-allocate, we can only free the
10281 old relocs if they were allocated with bfd_malloc.
10282 This is not true when keep_memory is in effect. */
10283 if (!link_info->keep_memory)
10284 free (*internal_relocs_p);
10285 }
10286 else
10287 free (*internal_relocs_p);
10288 relax_info->allocated_relocs = new_relocs;
10289 relax_info->allocated_relocs_count = new_relocs_count;
10290 elf_section_data (sec)->relocs = new_relocs;
10291 sec->reloc_count++;
10292 relax_info->relocs_count = sec->reloc_count;
10293 *internal_relocs_p = new_relocs;
10294 }
10295 else
10296 {
10297 if (insert_at != sec->reloc_count)
10298 {
10299 unsigned idx;
10300 for (idx = sec->reloc_count; idx > insert_at; idx--)
10301 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
10302 }
10303 (*internal_relocs_p)[insert_at] = this_rela;
10304 sec->reloc_count++;
10305 if (relax_info->allocated_relocs)
10306 relax_info->relocs_count = sec->reloc_count;
10307 }
10308 }
10309 return TRUE;
10310}
10311
10312
e0001a05
NC		 10313/* This is similar to relax_section except that when a target is moved,
10314 we shift addresses up. We also need to modify the size. This
10315 algorithm does NOT allow for relocations into the middle of the
10316 property sections. */
10317
43cd72b9 10318static bfd_boolean
7fa3d080
BW		 10319relax_property_section (bfd *abfd,
10320 asection *sec,
10321 struct bfd_link_info *link_info)
e0001a05
NC		 10322{
10323 Elf_Internal_Rela *internal_relocs;
10324 bfd_byte *contents;
1d25768e 10325 unsigned i;
e0001a05 10326 bfd_boolean ok = TRUE;
43cd72b9
BW		 10327 bfd_boolean is_full_prop_section;
10328 size_t last_zfill_target_offset = 0;
10329 asection *last_zfill_target_sec = NULL;
10330 bfd_size_type sec_size;
1d25768e 10331 bfd_size_type entry_size;
e0001a05 10332
43cd72b9 10333 sec_size = bfd_get_section_limit (abfd, sec);
68ffbac6 10334 internal_relocs = retrieve_internal_relocs (abfd, sec,
e0001a05
NC		 10335 link_info->keep_memory);
10336 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 10337 if (contents == NULL && sec_size != 0)
e0001a05
NC		 10338 {
10339 ok = FALSE;
10340 goto error_return;
10341 }
10342
1d25768e
BW		 10343 is_full_prop_section = xtensa_is_proptable_section (sec);
10344 if (is_full_prop_section)
10345 entry_size = 12;
10346 else
10347 entry_size = 8;
43cd72b9
BW		 10348
10349 if (internal_relocs)
e0001a05 10350 {
43cd72b9 10351 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 10352 {
10353 Elf_Internal_Rela *irel;
10354 xtensa_relax_info *target_relax_info;
e0001a05
NC		 10355 unsigned r_type;
10356 asection *target_sec;
43cd72b9
BW		 10357 literal_value val;
10358 bfd_byte *size_p, *flags_p;
e0001a05
NC		 10359
10360 /* Locally change the source address.
10361 Translate the target to the new target address.
10362 If it points to this section and has been removed, MOVE IT.
10363 Also, don't forget to modify the associated SIZE at
10364 (offset + 4). */
10365
10366 irel = &internal_relocs[i];
10367 r_type = ELF32_R_TYPE (irel->r_info);
10368 if (r_type == R_XTENSA_NONE)
10369 continue;
10370
43cd72b9
BW		 10371 /* Find the literal value. */
10372 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
10373 size_p = &contents[irel->r_offset + 4];
10374 flags_p = NULL;
10375 if (is_full_prop_section)
1d25768e
BW		 10376 flags_p = &contents[irel->r_offset + 8];
10377 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
e0001a05 10378
43cd72b9 10379 target_sec = r_reloc_get_section (&val.r_rel);
e0001a05
NC		 10380 target_relax_info = get_xtensa_relax_info (target_sec);
10381
10382 if (target_relax_info
43cd72b9
BW		 10383 && (target_relax_info->is_relaxable_literal_section
10384 || target_relax_info->is_relaxable_asm_section ))
e0001a05
NC		 10385 {
10386 /* Translate the relocation's destination. */
03669f1c
BW		 10387 bfd_vma old_offset = val.r_rel.target_offset;
10388 bfd_vma new_offset;
e0001a05 10389 long old_size, new_size;
071aa5c9
MF		 10390 int removed_by_old_offset =
10391 removed_by_actions_map (&target_relax_info->action_list,
10392 old_offset, FALSE);
10393 new_offset = old_offset - removed_by_old_offset;
e0001a05
NC		 10394
10395 /* Assert that we are not out of bounds. */
43cd72b9 10396 old_size = bfd_get_32 (abfd, size_p);
03669f1c 10397 new_size = old_size;
43cd72b9
BW		 10398
10399 if (old_size == 0)
10400 {
10401 /* Only the first zero-sized unreachable entry is
10402 allowed to expand. In this case the new offset
10403 should be the offset before the fill and the new
10404 size is the expansion size. For other zero-sized
10405 entries the resulting size should be zero with an
10406 offset before or after the fill address depending
10407 on whether the expanding unreachable entry
10408 preceeds it. */
03669f1c
BW		 10409 if (last_zfill_target_sec == 0
10410 || last_zfill_target_sec != target_sec
10411 || last_zfill_target_offset != old_offset)
43cd72b9 10412 {
03669f1c
BW		 10413 bfd_vma new_end_offset = new_offset;
10414
10415 /* Recompute the new_offset, but this time don't
10416 include any fill inserted by relaxation. */
071aa5c9
MF		 10417 removed_by_old_offset =
10418 removed_by_actions_map (&target_relax_info->action_list,
10419 old_offset, TRUE);
10420 new_offset = old_offset - removed_by_old_offset;
43cd72b9
BW		 10421
10422 /* If it is not unreachable and we have not yet
10423 seen an unreachable at this address, place it
10424 before the fill address. */
03669f1c
BW		 10425 if (flags_p && (bfd_get_32 (abfd, flags_p)
10426 & XTENSA_PROP_UNREACHABLE) != 0)
43cd72b9 10427 {
03669f1c
BW		 10428 new_size = new_end_offset - new_offset;
10429
43cd72b9 10430 last_zfill_target_sec = target_sec;
03669f1c 10431 last_zfill_target_offset = old_offset;
43cd72b9
BW		 10432 }
10433 }
10434 }
10435 else
071aa5c9
MF		 10436 {
10437 int removed_by_old_offset_size =
10438 removed_by_actions_map (&target_relax_info->action_list,
10439 old_offset + old_size, TRUE);
10440 new_size -= removed_by_old_offset_size - removed_by_old_offset;
10441 }
43cd72b9 10442
e0001a05
NC		 10443 if (new_size != old_size)
10444 {
10445 bfd_put_32 (abfd, new_size, size_p);
10446 pin_contents (sec, contents);
10447 }
43cd72b9 10448
03669f1c 10449 if (new_offset != old_offset)
e0001a05 10450 {
03669f1c 10451 bfd_vma diff = new_offset - old_offset;
e0001a05
NC		 10452 irel->r_addend += diff;
10453 pin_internal_relocs (sec, internal_relocs);
10454 }
10455 }
10456 }
10457 }
10458
10459 /* Combine adjacent property table entries. This is also done in
10460 finish_dynamic_sections() but at that point it's too late to
10461 reclaim the space in the output section, so we do this twice. */
10462
43cd72b9 10463 if (internal_relocs && (!link_info->relocatable
1d25768e 10464 || xtensa_is_littable_section (sec)))
e0001a05
NC		 10465 {
10466 Elf_Internal_Rela *last_irel = NULL;
1d25768e 10467 Elf_Internal_Rela *irel, *next_rel, *rel_end;
e0001a05 10468 int removed_bytes = 0;
1d25768e 10469 bfd_vma offset;
43cd72b9
BW		 10470 flagword predef_flags;
10471
43cd72b9 10472 predef_flags = xtensa_get_property_predef_flags (sec);
e0001a05 10473
1d25768e 10474 /* Walk over memory and relocations at the same time.
e0001a05
NC		 10475 This REQUIRES that the internal_relocs be sorted by offset. */
10476 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
10477 internal_reloc_compare);
e0001a05
NC		 10478
10479 pin_internal_relocs (sec, internal_relocs);
10480 pin_contents (sec, contents);
10481
1d25768e
BW		 10482 next_rel = internal_relocs;
10483 rel_end = internal_relocs + sec->reloc_count;
10484
a3ef2d63 10485 BFD_ASSERT (sec->size % entry_size == 0);
e0001a05 10486
a3ef2d63 10487 for (offset = 0; offset < sec->size; offset += entry_size)
e0001a05 10488 {
1d25768e 10489 Elf_Internal_Rela *offset_rel, *extra_rel;
e0001a05 10490 bfd_vma bytes_to_remove, size, actual_offset;
1d25768e 10491 bfd_boolean remove_this_rel;
43cd72b9 10492 flagword flags;
e0001a05 10493
1d25768e
BW		 10494 /* Find the first relocation for the entry at the current offset.
10495 Adjust the offsets of any extra relocations for the previous
10496 entry. */
10497 offset_rel = NULL;
10498 if (next_rel)
10499 {
10500 for (irel = next_rel; irel < rel_end; irel++)
10501 {
10502 if ((irel->r_offset == offset
10503 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10504 || irel->r_offset > offset)
10505 {
10506 offset_rel = irel;
10507 break;
10508 }
10509 irel->r_offset -= removed_bytes;
1d25768e
BW		 10510 }
10511 }
e0001a05 10512
1d25768e
BW		 10513 /* Find the next relocation (if there are any left). */
10514 extra_rel = NULL;
10515 if (offset_rel)
e0001a05 10516 {
1d25768e 10517 for (irel = offset_rel + 1; irel < rel_end; irel++)
e0001a05 10518 {
1d25768e
BW		 10519 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10520 {
10521 extra_rel = irel;
10522 break;
10523 }
e0001a05 10524 }
e0001a05
NC		 10525 }
10526
1d25768e
BW		 10527 /* Check if there are relocations on the current entry. There
10528 should usually be a relocation on the offset field. If there
10529 are relocations on the size or flags, then we can't optimize
10530 this entry. Also, find the next relocation to examine on the
10531 next iteration. */
10532 if (offset_rel)
e0001a05 10533 {
1d25768e 10534 if (offset_rel->r_offset >= offset + entry_size)
e0001a05 10535 {
1d25768e
BW		 10536 next_rel = offset_rel;
10537 /* There are no relocations on the current entry, but we
10538 might still be able to remove it if the size is zero. */
10539 offset_rel = NULL;
10540 }
10541 else if (offset_rel->r_offset > offset
10542 || (extra_rel
10543 && extra_rel->r_offset < offset + entry_size))
10544 {
10545 /* There is a relocation on the size or flags, so we can't
10546 do anything with this entry. Continue with the next. */
10547 next_rel = offset_rel;
10548 continue;
10549 }
10550 else
10551 {
10552 BFD_ASSERT (offset_rel->r_offset == offset);
10553 offset_rel->r_offset -= removed_bytes;
10554 next_rel = offset_rel + 1;
e0001a05 10555 }
e0001a05 10556 }
1d25768e
BW		 10557 else
10558 next_rel = NULL;
e0001a05 10559
1d25768e 10560 remove_this_rel = FALSE;
e0001a05
NC		 10561 bytes_to_remove = 0;
10562 actual_offset = offset - removed_bytes;
10563 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10564
68ffbac6 10565 if (is_full_prop_section)
43cd72b9
BW		 10566 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10567 else
10568 flags = predef_flags;
10569
1d25768e
BW		 10570 if (size == 0
10571 && (flags & XTENSA_PROP_ALIGN) == 0
10572 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
e0001a05 10573 {
43cd72b9
BW		 10574 /* Always remove entries with zero size and no alignment. */
10575 bytes_to_remove = entry_size;
1d25768e
BW		 10576 if (offset_rel)
10577 remove_this_rel = TRUE;
e0001a05 10578 }
1d25768e
BW		 10579 else if (offset_rel
10580 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
e0001a05 10581 {
1d25768e 10582 if (last_irel)
e0001a05 10583 {
1d25768e
BW		 10584 flagword old_flags;
10585 bfd_vma old_size =
10586 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10587 bfd_vma old_address =
10588 (last_irel->r_addend
10589 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10590 bfd_vma new_address =
10591 (offset_rel->r_addend
10592 + bfd_get_32 (abfd, &contents[actual_offset]));
68ffbac6 10593 if (is_full_prop_section)
1d25768e
BW		 10594 old_flags = bfd_get_32
10595 (abfd, &contents[last_irel->r_offset + 8]);
10596 else
10597 old_flags = predef_flags;
10598
10599 if ((ELF32_R_SYM (offset_rel->r_info)
10600 == ELF32_R_SYM (last_irel->r_info))
10601 && old_address + old_size == new_address
10602 && old_flags == flags
10603 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10604 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
e0001a05 10605 {
1d25768e
BW		 10606 /* Fix the old size. */
10607 bfd_put_32 (abfd, old_size + size,
10608 &contents[last_irel->r_offset + 4]);
10609 bytes_to_remove = entry_size;
10610 remove_this_rel = TRUE;
e0001a05
NC		 10611 }
10612 else
1d25768e 10613 last_irel = offset_rel;
e0001a05 10614 }
1d25768e
BW		 10615 else
10616 last_irel = offset_rel;
e0001a05
NC		 10617 }
10618
1d25768e 10619 if (remove_this_rel)
e0001a05 10620 {
1d25768e 10621 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3df502ae 10622 offset_rel->r_offset = 0;
e0001a05
NC		 10623 }
10624
10625 if (bytes_to_remove != 0)
10626 {
10627 removed_bytes += bytes_to_remove;
a3ef2d63 10628 if (offset + bytes_to_remove < sec->size)
e0001a05 10629 memmove (&contents[actual_offset],
43cd72b9 10630 &contents[actual_offset + bytes_to_remove],
a3ef2d63 10631 sec->size - offset - bytes_to_remove);
e0001a05
NC		 10632 }
10633 }
10634
43cd72b9 10635 if (removed_bytes)
e0001a05 10636 {
1d25768e
BW		 10637 /* Fix up any extra relocations on the last entry. */
10638 for (irel = next_rel; irel < rel_end; irel++)
10639 irel->r_offset -= removed_bytes;
10640
e0001a05 10641 /* Clear the removed bytes. */
a3ef2d63 10642 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
e0001a05 10643
a3ef2d63
BW		 10644 if (sec->rawsize == 0)
10645 sec->rawsize = sec->size;
10646 sec->size -= removed_bytes;
e901de89
BW		 10647
10648 if (xtensa_is_littable_section (sec))
10649 {
f0e6fdb2
BW		 10650 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10651 if (sgotloc)
10652 sgotloc->size -= removed_bytes;
e901de89 10653 }
e0001a05
NC		 10654 }
10655 }
e901de89 10656
e0001a05
NC		 10657 error_return:
10658 release_internal_relocs (sec, internal_relocs);
10659 release_contents (sec, contents);
10660 return ok;
10661}
10662
10663\f
10664/* Third relaxation pass. */
10665
10666/* Change symbol values to account for removed literals. */
10667
43cd72b9 10668bfd_boolean
7fa3d080 10669relax_section_symbols (bfd *abfd, asection *sec)
e0001a05
NC		 10670{
10671 xtensa_relax_info *relax_info;
10672 unsigned int sec_shndx;
10673 Elf_Internal_Shdr *symtab_hdr;
10674 Elf_Internal_Sym *isymbuf;
10675 unsigned i, num_syms, num_locals;
10676
10677 relax_info = get_xtensa_relax_info (sec);
10678 BFD_ASSERT (relax_info);
10679
43cd72b9
BW		 10680 if (!relax_info->is_relaxable_literal_section
10681 && !relax_info->is_relaxable_asm_section)
e0001a05
NC		 10682 return TRUE;
10683
10684 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10685
10686 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10687 isymbuf = retrieve_local_syms (abfd);
10688
10689 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10690 num_locals = symtab_hdr->sh_info;
10691
10692 /* Adjust the local symbols defined in this section. */
10693 for (i = 0; i < num_locals; i++)
10694 {
10695 Elf_Internal_Sym *isym = &isymbuf[i];
10696
10697 if (isym->st_shndx == sec_shndx)
10698 {
03669f1c 10699 bfd_vma orig_addr = isym->st_value;
071aa5c9
MF		 10700 int removed = removed_by_actions_map (&relax_info->action_list,
10701 orig_addr, FALSE);
43cd72b9 10702
071aa5c9 10703 isym->st_value -= removed;
03669f1c
BW		 10704 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10705 isym->st_size -=
071aa5c9
MF		 10706 removed_by_actions_map (&relax_info->action_list,
10707 orig_addr + isym->st_size, FALSE) -
10708 removed;
e0001a05
NC		 10709 }
10710 }
10711
10712 /* Now adjust the global symbols defined in this section. */
10713 for (i = 0; i < (num_syms - num_locals); i++)
10714 {
10715 struct elf_link_hash_entry *sym_hash;
10716
10717 sym_hash = elf_sym_hashes (abfd)[i];
10718
10719 if (sym_hash->root.type == bfd_link_hash_warning)
10720 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10721
10722 if ((sym_hash->root.type == bfd_link_hash_defined
10723 || sym_hash->root.type == bfd_link_hash_defweak)
10724 && sym_hash->root.u.def.section == sec)
10725 {
03669f1c 10726 bfd_vma orig_addr = sym_hash->root.u.def.value;
071aa5c9
MF		 10727 int removed = removed_by_actions_map (&relax_info->action_list,
10728 orig_addr, FALSE);
43cd72b9 10729
071aa5c9 10730 sym_hash->root.u.def.value -= removed;
43cd72b9 10731
03669f1c
BW		 10732 if (sym_hash->type == STT_FUNC)
10733 sym_hash->size -=
071aa5c9
MF		 10734 removed_by_actions_map (&relax_info->action_list,
10735 orig_addr + sym_hash->size, FALSE) -
10736 removed;
e0001a05
NC		 10737 }
10738 }
10739
10740 return TRUE;
10741}
10742
10743\f
10744/* "Fix" handling functions, called while performing relocations. */
10745
43cd72b9 10746static bfd_boolean
7fa3d080
BW		 10747do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10748 bfd *input_bfd,
10749 asection *input_section,
10750 bfd_byte *contents)
e0001a05
NC		 10751{
10752 r_reloc r_rel;
10753 asection *sec, *old_sec;
10754 bfd_vma old_offset;
10755 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05
NC		 10756 reloc_bfd_fix *fix;
10757
10758 if (r_type == R_XTENSA_NONE)
43cd72b9 10759 return TRUE;
e0001a05 10760
43cd72b9
BW		 10761 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10762 if (!fix)
10763 return TRUE;
e0001a05 10764
43cd72b9
BW		 10765 r_reloc_init (&r_rel, input_bfd, rel, contents,
10766 bfd_get_section_limit (input_bfd, input_section));
e0001a05 10767 old_sec = r_reloc_get_section (&r_rel);
43cd72b9
BW		 10768 old_offset = r_rel.target_offset;
10769
10770 if (!old_sec || !r_reloc_is_defined (&r_rel))
e0001a05 10771 {
43cd72b9
BW		 10772 if (r_type != R_XTENSA_ASM_EXPAND)
10773 {
10774 (*_bfd_error_handler)
10775 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10776 input_bfd, input_section, rel->r_offset,
10777 elf_howto_table[r_type].name);
10778 return FALSE;
10779 }
e0001a05
NC		 10780 /* Leave it be. Resolution will happen in a later stage. */
10781 }
10782 else
10783 {
10784 sec = fix->target_sec;
10785 rel->r_addend += ((sec->output_offset + fix->target_offset)
10786 - (old_sec->output_offset + old_offset));
10787 }
43cd72b9 10788 return TRUE;
e0001a05
NC		 10789}
10790
10791
10792static void
7fa3d080
BW		 10793do_fix_for_final_link (Elf_Internal_Rela *rel,
10794 bfd *input_bfd,
10795 asection *input_section,
10796 bfd_byte *contents,
10797 bfd_vma *relocationp)
e0001a05
NC		 10798{
10799 asection *sec;
10800 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05 10801 reloc_bfd_fix *fix;
43cd72b9 10802 bfd_vma fixup_diff;
e0001a05
NC		 10803
10804 if (r_type == R_XTENSA_NONE)
10805 return;
10806
43cd72b9
BW		 10807 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10808 if (!fix)
e0001a05
NC		 10809 return;
10810
10811 sec = fix->target_sec;
43cd72b9
BW		 10812
10813 fixup_diff = rel->r_addend;
10814 if (elf_howto_table[fix->src_type].partial_inplace)
10815 {
10816 bfd_vma inplace_val;
10817 BFD_ASSERT (fix->src_offset
10818 < bfd_get_section_limit (input_bfd, input_section));
10819 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10820 fixup_diff += inplace_val;
10821 }
10822
e0001a05
NC		 10823 *relocationp = (sec->output_section->vma
10824 + sec->output_offset
43cd72b9 10825 + fix->target_offset - fixup_diff);
e0001a05
NC		 10826}
10827
10828\f
10829/* Miscellaneous utility functions.... */
10830
10831static asection *
f0e6fdb2 10832elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
e0001a05 10833{
f0e6fdb2
BW		 10834 struct elf_xtensa_link_hash_table *htab;
10835 bfd *dynobj;
e0001a05
NC		 10836 char plt_name[10];
10837
10838 if (chunk == 0)
f0e6fdb2
BW		 10839 {
10840 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 10841 if (htab == NULL)
10842 return NULL;
10843
f0e6fdb2
BW		 10844 return htab->splt;
10845 }
e0001a05 10846
f0e6fdb2 10847 dynobj = elf_hash_table (info)->dynobj;
e0001a05 10848 sprintf (plt_name, ".plt.%u", chunk);
3d4d4302 10849 return bfd_get_linker_section (dynobj, plt_name);
e0001a05
NC		 10850}
10851
10852
10853static asection *
f0e6fdb2 10854elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
e0001a05 10855{
f0e6fdb2
BW		 10856 struct elf_xtensa_link_hash_table *htab;
10857 bfd *dynobj;
e0001a05
NC		 10858 char got_name[14];
10859
10860 if (chunk == 0)
f0e6fdb2
BW		 10861 {
10862 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 10863 if (htab == NULL)
10864 return NULL;
f0e6fdb2
BW		 10865 return htab->sgotplt;
10866 }
e0001a05 10867
f0e6fdb2 10868 dynobj = elf_hash_table (info)->dynobj;
e0001a05 10869 sprintf (got_name, ".got.plt.%u", chunk);
3d4d4302 10870 return bfd_get_linker_section (dynobj, got_name);
e0001a05
NC		 10871}
10872
10873
10874/* Get the input section for a given symbol index.
10875 If the symbol is:
10876 . a section symbol, return the section;
10877 . a common symbol, return the common section;
10878 . an undefined symbol, return the undefined section;
10879 . an indirect symbol, follow the links;
10880 . an absolute value, return the absolute section. */
10881
10882static asection *
7fa3d080 10883get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10884{
10885 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10886 asection *target_sec = NULL;
43cd72b9 10887 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 10888 {
10889 Elf_Internal_Sym *isymbuf;
10890 unsigned int section_index;
10891
10892 isymbuf = retrieve_local_syms (abfd);
10893 section_index = isymbuf[r_symndx].st_shndx;
10894
10895 if (section_index == SHN_UNDEF)
10896 target_sec = bfd_und_section_ptr;
e0001a05
NC		 10897 else if (section_index == SHN_ABS)
10898 target_sec = bfd_abs_section_ptr;
10899 else if (section_index == SHN_COMMON)
10900 target_sec = bfd_com_section_ptr;
43cd72b9 10901 else
cb33740c 10902 target_sec = bfd_section_from_elf_index (abfd, section_index);
e0001a05
NC		 10903 }
10904 else
10905 {
10906 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10907 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10908
10909 while (h->root.type == bfd_link_hash_indirect
10910 || h->root.type == bfd_link_hash_warning)
10911 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10912
10913 switch (h->root.type)
10914 {
10915 case bfd_link_hash_defined:
10916 case bfd_link_hash_defweak:
10917 target_sec = h->root.u.def.section;
10918 break;
10919 case bfd_link_hash_common:
10920 target_sec = bfd_com_section_ptr;
10921 break;
10922 case bfd_link_hash_undefined:
10923 case bfd_link_hash_undefweak:
10924 target_sec = bfd_und_section_ptr;
10925 break;
10926 default: /* New indirect warning. */
10927 target_sec = bfd_und_section_ptr;
10928 break;
10929 }
10930 }
10931 return target_sec;
10932}
10933
10934
10935static struct elf_link_hash_entry *
7fa3d080 10936get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10937{
10938 unsigned long indx;
10939 struct elf_link_hash_entry *h;
10940 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10941
10942 if (r_symndx < symtab_hdr->sh_info)
10943 return NULL;
43cd72b9 10944
e0001a05
NC		 10945 indx = r_symndx - symtab_hdr->sh_info;
10946 h = elf_sym_hashes (abfd)[indx];
10947 while (h->root.type == bfd_link_hash_indirect
10948 || h->root.type == bfd_link_hash_warning)
10949 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10950 return h;
10951}
10952
10953
10954/* Get the section-relative offset for a symbol number. */
10955
10956static bfd_vma
7fa3d080 10957get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10958{
10959 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10960 bfd_vma offset = 0;
10961
43cd72b9 10962 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 10963 {
10964 Elf_Internal_Sym *isymbuf;
10965 isymbuf = retrieve_local_syms (abfd);
10966 offset = isymbuf[r_symndx].st_value;
10967 }
10968 else
10969 {
10970 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10971 struct elf_link_hash_entry *h =
10972 elf_sym_hashes (abfd)[indx];
10973
10974 while (h->root.type == bfd_link_hash_indirect
10975 || h->root.type == bfd_link_hash_warning)
10976 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10977 if (h->root.type == bfd_link_hash_defined
10978 || h->root.type == bfd_link_hash_defweak)
10979 offset = h->root.u.def.value;
10980 }
10981 return offset;
10982}
10983
10984
10985static bfd_boolean
7fa3d080 10986is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
43cd72b9
BW		 10987{
10988 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10989 struct elf_link_hash_entry *h;
10990
10991 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10992 if (h && h->root.type == bfd_link_hash_defweak)
10993 return TRUE;
10994 return FALSE;
10995}
10996
10997
10998static bfd_boolean
7fa3d080
BW		 10999pcrel_reloc_fits (xtensa_opcode opc,
11000 int opnd,
11001 bfd_vma self_address,
11002 bfd_vma dest_address)
e0001a05 11003{
43cd72b9
BW		 11004 xtensa_isa isa = xtensa_default_isa;
11005 uint32 valp = dest_address;
11006 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
11007 || xtensa_operand_encode (isa, opc, opnd, &valp))
11008 return FALSE;
11009 return TRUE;
e0001a05
NC		 11010}
11011
11012
68ffbac6 11013static bfd_boolean
7fa3d080 11014xtensa_is_property_section (asection *sec)
e0001a05 11015{
1d25768e
BW		 11016 if (xtensa_is_insntable_section (sec)
11017 || xtensa_is_littable_section (sec)
11018 || xtensa_is_proptable_section (sec))
b614a702 11019 return TRUE;
e901de89 11020
1d25768e
BW		 11021 return FALSE;
11022}
11023
11024
68ffbac6 11025static bfd_boolean
1d25768e
BW		 11026xtensa_is_insntable_section (asection *sec)
11027{
11028 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
11029 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
e901de89
BW		 11030 return TRUE;
11031
e901de89
BW		 11032 return FALSE;
11033}
11034
11035
68ffbac6 11036static bfd_boolean
7fa3d080 11037xtensa_is_littable_section (asection *sec)
e901de89 11038{
1d25768e
BW		 11039 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
11040 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
b614a702 11041 return TRUE;
e901de89 11042
1d25768e
BW		 11043 return FALSE;
11044}
11045
11046
68ffbac6 11047static bfd_boolean
1d25768e
BW		 11048xtensa_is_proptable_section (asection *sec)
11049{
11050 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
11051 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
e901de89 11052 return TRUE;
e0001a05 11053
e901de89 11054 return FALSE;
e0001a05
NC		 11055}
11056
11057
43cd72b9 11058static int
7fa3d080 11059internal_reloc_compare (const void *ap, const void *bp)
e0001a05 11060{
43cd72b9
BW		 11061 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11062 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11063
11064 if (a->r_offset != b->r_offset)
11065 return (a->r_offset - b->r_offset);
11066
11067 /* We don't need to sort on these criteria for correctness,
11068 but enforcing a more strict ordering prevents unstable qsort
11069 from behaving differently with different implementations.
11070 Without the code below we get correct but different results
11071 on Solaris 2.7 and 2.8. We would like to always produce the
11072 same results no matter the host. */
11073
11074 if (a->r_info != b->r_info)
11075 return (a->r_info - b->r_info);
11076
11077 return (a->r_addend - b->r_addend);
e0001a05
NC		 11078}
11079
11080
11081static int
7fa3d080 11082internal_reloc_matches (const void *ap, const void *bp)
e0001a05
NC		 11083{
11084 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11085 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11086
43cd72b9
BW		 11087 /* Check if one entry overlaps with the other; this shouldn't happen
11088 except when searching for a match. */
e0001a05
NC		 11089 return (a->r_offset - b->r_offset);
11090}
11091
11092
74869ac7
BW		 11093/* Predicate function used to look up a section in a particular group. */
11094
11095static bfd_boolean
11096match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
11097{
11098 const char *gname = inf;
11099 const char *group_name = elf_group_name (sec);
68ffbac6 11100
74869ac7
BW		 11101 return (group_name == gname
11102 || (group_name != NULL
11103 && gname != NULL
11104 && strcmp (group_name, gname) == 0));
11105}
11106
11107
1d25768e
BW		 11108static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
11109
51c8ebc1
BW		 11110static char *
11111xtensa_property_section_name (asection *sec, const char *base_name)
e0001a05 11112{
74869ac7
BW		 11113 const char *suffix, *group_name;
11114 char *prop_sec_name;
74869ac7
BW		 11115
11116 group_name = elf_group_name (sec);
11117 if (group_name)
11118 {
11119 suffix = strrchr (sec->name, '.');
11120 if (suffix == sec->name)
11121 suffix = 0;
11122 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
11123 + (suffix ? strlen (suffix) : 0));
11124 strcpy (prop_sec_name, base_name);
11125 if (suffix)
11126 strcat (prop_sec_name, suffix);
11127 }
11128 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
e0001a05 11129 {
43cd72b9 11130 char *linkonce_kind = 0;
b614a702 11131
68ffbac6 11132 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
7db48a12 11133 linkonce_kind = "x.";
68ffbac6 11134 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
7db48a12 11135 linkonce_kind = "p.";
43cd72b9
BW		 11136 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
11137 linkonce_kind = "prop.";
e0001a05 11138 else
b614a702
BW		 11139 abort ();
11140
43cd72b9
BW		 11141 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
11142 + strlen (linkonce_kind) + 1);
b614a702 11143 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
43cd72b9 11144 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
b614a702
BW		 11145
11146 suffix = sec->name + linkonce_len;
096c35a7 11147 /* For backward compatibility, replace "t." instead of inserting
43cd72b9 11148 the new linkonce_kind (but not for "prop" sections). */
0112cd26 11149 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
43cd72b9
BW		 11150 suffix += 2;
11151 strcat (prop_sec_name + linkonce_len, suffix);
74869ac7
BW		 11152 }
11153 else
11154 prop_sec_name = strdup (base_name);
11155
51c8ebc1
BW		 11156 return prop_sec_name;
11157}
11158
11159
11160static asection *
11161xtensa_get_property_section (asection *sec, const char *base_name)
11162{
11163 char *prop_sec_name;
11164 asection *prop_sec;
11165
11166 prop_sec_name = xtensa_property_section_name (sec, base_name);
11167 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11168 match_section_group,
11169 (void *) elf_group_name (sec));
11170 free (prop_sec_name);
11171 return prop_sec;
11172}
11173
11174
11175asection *
11176xtensa_make_property_section (asection *sec, const char *base_name)
11177{
11178 char *prop_sec_name;
11179 asection *prop_sec;
11180
74869ac7 11181 /* Check if the section already exists. */
51c8ebc1 11182 prop_sec_name = xtensa_property_section_name (sec, base_name);
74869ac7
BW		 11183 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11184 match_section_group,
51c8ebc1 11185 (void *) elf_group_name (sec));
74869ac7
BW		 11186 /* If not, create it. */
11187 if (! prop_sec)
11188 {
11189 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
11190 flags |= (bfd_get_section_flags (sec->owner, sec)
11191 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
11192
11193 prop_sec = bfd_make_section_anyway_with_flags
11194 (sec->owner, strdup (prop_sec_name), flags);
11195 if (! prop_sec)
11196 return 0;
b614a702 11197
51c8ebc1 11198 elf_group_name (prop_sec) = elf_group_name (sec);
e0001a05
NC		 11199 }
11200
74869ac7
BW		 11201 free (prop_sec_name);
11202 return prop_sec;
e0001a05
NC		 11203}
11204
43cd72b9
BW		 11205
11206flagword
7fa3d080 11207xtensa_get_property_predef_flags (asection *sec)
43cd72b9 11208{
1d25768e 11209 if (xtensa_is_insntable_section (sec))
43cd72b9 11210 return (XTENSA_PROP_INSN
99ded152 11211 | XTENSA_PROP_NO_TRANSFORM
43cd72b9
BW		 11212 | XTENSA_PROP_INSN_NO_REORDER);
11213
11214 if (xtensa_is_littable_section (sec))
11215 return (XTENSA_PROP_LITERAL
99ded152 11216 | XTENSA_PROP_NO_TRANSFORM
43cd72b9
BW		 11217 | XTENSA_PROP_INSN_NO_REORDER);
11218
11219 return 0;
11220}
11221
e0001a05
NC		 11222\f
11223/* Other functions called directly by the linker. */
11224
11225bfd_boolean
7fa3d080
BW		 11226xtensa_callback_required_dependence (bfd *abfd,
11227 asection *sec,
11228 struct bfd_link_info *link_info,
11229 deps_callback_t callback,
11230 void *closure)
e0001a05
NC		 11231{
11232 Elf_Internal_Rela *internal_relocs;
11233 bfd_byte *contents;
11234 unsigned i;
11235 bfd_boolean ok = TRUE;
43cd72b9
BW		 11236 bfd_size_type sec_size;
11237
11238 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 11239
11240 /* ".plt*" sections have no explicit relocations but they contain L32R
11241 instructions that reference the corresponding ".got.plt*" sections. */
11242 if ((sec->flags & SEC_LINKER_CREATED) != 0
0112cd26 11243 && CONST_STRNEQ (sec->name, ".plt"))
e0001a05
NC		 11244 {
11245 asection *sgotplt;
11246
11247 /* Find the corresponding ".got.plt*" section. */
11248 if (sec->name[4] == '\0')
3d4d4302 11249 sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");
e0001a05
NC		 11250 else
11251 {
11252 char got_name[14];
11253 int chunk = 0;
11254
11255 BFD_ASSERT (sec->name[4] == '.');
11256 chunk = strtol (&sec->name[5], NULL, 10);
11257
11258 sprintf (got_name, ".got.plt.%u", chunk);
3d4d4302 11259 sgotplt = bfd_get_linker_section (sec->owner, got_name);
e0001a05
NC		 11260 }
11261 BFD_ASSERT (sgotplt);
11262
11263 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11264 section referencing a literal at the very beginning of
11265 ".got.plt". This is very close to the real dependence, anyway. */
43cd72b9 11266 (*callback) (sec, sec_size, sgotplt, 0, closure);
e0001a05
NC		 11267 }
11268
13161072
BW		 11269 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11270 when building uclibc, which runs "ld -b binary /dev/null". */
11271 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
11272 return ok;
11273
68ffbac6 11274 internal_relocs = retrieve_internal_relocs (abfd, sec,
e0001a05
NC		 11275 link_info->keep_memory);
11276 if (internal_relocs == NULL
43cd72b9 11277 || sec->reloc_count == 0)
e0001a05
NC		 11278 return ok;
11279
11280 /* Cache the contents for the duration of this scan. */
11281 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 11282 if (contents == NULL && sec_size != 0)
e0001a05
NC		 11283 {
11284 ok = FALSE;
11285 goto error_return;
11286 }
11287
43cd72b9
BW		 11288 if (!xtensa_default_isa)
11289 xtensa_default_isa = xtensa_isa_init (0, 0);
e0001a05 11290
43cd72b9 11291 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 11292 {
11293 Elf_Internal_Rela *irel = &internal_relocs[i];
43cd72b9 11294 if (is_l32r_relocation (abfd, sec, contents, irel))
e0001a05
NC		 11295 {
11296 r_reloc l32r_rel;
11297 asection *target_sec;
11298 bfd_vma target_offset;
43cd72b9
BW		 11299
11300 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
e0001a05
NC		 11301 target_sec = NULL;
11302 target_offset = 0;
11303 /* L32Rs must be local to the input file. */
11304 if (r_reloc_is_defined (&l32r_rel))
11305 {
11306 target_sec = r_reloc_get_section (&l32r_rel);
43cd72b9 11307 target_offset = l32r_rel.target_offset;
e0001a05
NC		 11308 }
11309 (*callback) (sec, irel->r_offset, target_sec, target_offset,
11310 closure);
11311 }
11312 }
11313
11314 error_return:
11315 release_internal_relocs (sec, internal_relocs);
11316 release_contents (sec, contents);
11317 return ok;
11318}
11319
2f89ff8d
L		 11320/* The default literal sections should always be marked as "code" (i.e.,
11321 SHF_EXECINSTR). This is particularly important for the Linux kernel
11322 module loader so that the literals are not placed after the text. */
b35d266b 11323static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
2f89ff8d 11324{
0112cd26
NC		 11325 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11326 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11327 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2caa7ca0 11328 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
0112cd26 11329 { NULL, 0, 0, 0, 0 }
7f4d3958 11330};
e0001a05 11331\f
ae95ffa6 11332#define ELF_TARGET_ID XTENSA_ELF_DATA
e0001a05 11333#ifndef ELF_ARCH
6d00b590 11334#define TARGET_LITTLE_SYM xtensa_elf32_le_vec
e0001a05 11335#define TARGET_LITTLE_NAME "elf32-xtensa-le"
6d00b590 11336#define TARGET_BIG_SYM xtensa_elf32_be_vec
e0001a05
NC		 11337#define TARGET_BIG_NAME "elf32-xtensa-be"
11338#define ELF_ARCH bfd_arch_xtensa
11339
4af0a1d8
BW		 11340#define ELF_MACHINE_CODE EM_XTENSA
11341#define ELF_MACHINE_ALT1 EM_XTENSA_OLD
e0001a05
NC		 11342
11343#if XCHAL_HAVE_MMU
11344#define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
11345#else /* !XCHAL_HAVE_MMU */
11346#define ELF_MAXPAGESIZE 1
11347#endif /* !XCHAL_HAVE_MMU */
11348#endif /* ELF_ARCH */
11349
11350#define elf_backend_can_gc_sections 1
11351#define elf_backend_can_refcount 1
11352#define elf_backend_plt_readonly 1
11353#define elf_backend_got_header_size 4
11354#define elf_backend_want_dynbss 0
11355#define elf_backend_want_got_plt 1
11356
11357#define elf_info_to_howto elf_xtensa_info_to_howto_rela
11358
28dbbc02
BW		 11359#define bfd_elf32_mkobject elf_xtensa_mkobject
11360
e0001a05
NC		 11361#define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11362#define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11363#define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11364#define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11365#define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
157090f7
AM		 11366#define bfd_elf32_bfd_reloc_name_lookup \
11367 elf_xtensa_reloc_name_lookup
e0001a05 11368#define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
f0e6fdb2 11369#define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
e0001a05
NC		 11370
11371#define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11372#define elf_backend_check_relocs elf_xtensa_check_relocs
e0001a05
NC		 11373#define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11374#define elf_backend_discard_info elf_xtensa_discard_info
11375#define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11376#define elf_backend_final_write_processing elf_xtensa_final_write_processing
11377#define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11378#define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11379#define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11380#define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
11381#define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11382#define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
95147441 11383#define elf_backend_hide_symbol elf_xtensa_hide_symbol
e0001a05
NC		 11384#define elf_backend_object_p elf_xtensa_object_p
11385#define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11386#define elf_backend_relocate_section elf_xtensa_relocate_section
11387#define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
28dbbc02 11388#define elf_backend_always_size_sections elf_xtensa_always_size_sections
74541ad4
AM		 11389#define elf_backend_omit_section_dynsym \
11390 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
29ef7005 11391#define elf_backend_special_sections elf_xtensa_special_sections
a77dc2cc 11392#define elf_backend_action_discarded elf_xtensa_action_discarded
28dbbc02 11393#define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
e0001a05
NC		 11394
11395#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.304103 seconds and 4 git commands to generate.