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