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