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