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