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