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