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