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