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