projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove trailing white spaces on gas
[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;
3d4d4302
AM		 1417 htab->splt = bfd_get_linker_section (dynobj, ".plt");
1418 htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
1419 htab->sgot = bfd_get_linker_section (dynobj, ".got");
1420 htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1421 htab->srelgot = bfd_get_linker_section (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). */
3d4d4302
AM		 1438 htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
1439 flags);
f0e6fdb2
BW		 1440 if (htab->sgotloc == NULL
1441 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
e901de89
BW		 1442 return FALSE;
1443
e0001a05 1444 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
3d4d4302
AM		 1445 htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
1446 noalloc_flags);
f0e6fdb2
BW		 1447 if (htab->spltlittbl == NULL
1448 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
e0001a05
NC		 1449 return FALSE;
1450
1451 return TRUE;
1452}
1453
1454
1455static bfd_boolean
f0e6fdb2 1456add_extra_plt_sections (struct bfd_link_info *info, int count)
e0001a05 1457{
f0e6fdb2 1458 bfd *dynobj = elf_hash_table (info)->dynobj;
e0001a05
NC		 1459 int chunk;
1460
1461 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1462 ".got.plt" sections. */
1463 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1464 {
1465 char *sname;
1466 flagword flags;
1467 asection *s;
1468
1469 /* Stop when we find a section has already been created. */
f0e6fdb2 1470 if (elf_xtensa_get_plt_section (info, chunk))
e0001a05
NC		 1471 break;
1472
1473 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1474 | SEC_LINKER_CREATED | SEC_READONLY);
1475
1476 sname = (char *) bfd_malloc (10);
1477 sprintf (sname, ".plt.%u", chunk);
3d4d4302 1478 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);
e0001a05 1479 if (s == NULL
e0001a05
NC		 1480 || ! bfd_set_section_alignment (dynobj, s, 2))
1481 return FALSE;
1482
1483 sname = (char *) bfd_malloc (14);
1484 sprintf (sname, ".got.plt.%u", chunk);
3d4d4302 1485 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);
e0001a05 1486 if (s == NULL
e0001a05
NC		 1487 || ! bfd_set_section_alignment (dynobj, s, 2))
1488 return FALSE;
1489 }
1490
1491 return TRUE;
1492}
1493
1494
1495/* Adjust a symbol defined by a dynamic object and referenced by a
1496 regular object. The current definition is in some section of the
1497 dynamic object, but we're not including those sections. We have to
1498 change the definition to something the rest of the link can
1499 understand. */
1500
1501static bfd_boolean
7fa3d080
BW		 1502elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1503 struct elf_link_hash_entry *h)
e0001a05
NC		 1504{
1505 /* If this is a weak symbol, and there is a real definition, the
1506 processor independent code will have arranged for us to see the
1507 real definition first, and we can just use the same value. */
7fa3d080 1508 if (h->u.weakdef)
e0001a05 1509 {
f6e332e6
AM		 1510 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1511 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1512 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1513 h->root.u.def.value = h->u.weakdef->root.u.def.value;
e0001a05
NC		 1514 return TRUE;
1515 }
1516
1517 /* This is a reference to a symbol defined by a dynamic object. The
1518 reference must go through the GOT, so there's no need for COPY relocs,
1519 .dynbss, etc. */
1520
1521 return TRUE;
1522}
1523
1524
e0001a05 1525static bfd_boolean
f1ab2340 1526elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
e0001a05 1527{
f1ab2340
BW		 1528 struct bfd_link_info *info;
1529 struct elf_xtensa_link_hash_table *htab;
28dbbc02 1530 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
e0001a05 1531
f1ab2340
BW		 1532 if (h->root.type == bfd_link_hash_indirect)
1533 return TRUE;
e0001a05 1534
f1ab2340
BW		 1535 info = (struct bfd_link_info *) arg;
1536 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1537 if (htab == NULL)
1538 return FALSE;
e0001a05 1539
28dbbc02
BW		 1540 /* If we saw any use of an IE model for this symbol, we can then optimize
1541 away GOT entries for any TLSDESC_FN relocs. */
1542 if ((eh->tls_type & GOT_TLS_IE) != 0)
1543 {
1544 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1545 h->got.refcount -= eh->tlsfunc_refcount;
1546 }
e0001a05 1547
28dbbc02 1548 if (! elf_xtensa_dynamic_symbol_p (h, info))
95147441 1549 elf_xtensa_make_sym_local (info, h);
e0001a05 1550
f1ab2340
BW		 1551 if (h->plt.refcount > 0)
1552 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
e0001a05
NC		 1553
1554 if (h->got.refcount > 0)
f1ab2340 1555 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
e0001a05
NC		 1556
1557 return TRUE;
1558}
1559
1560
1561static void
f0e6fdb2 1562elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
e0001a05 1563{
f0e6fdb2 1564 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 1565 bfd *i;
1566
f0e6fdb2 1567 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1568 if (htab == NULL)
1569 return;
f0e6fdb2 1570
e0001a05
NC		 1571 for (i = info->input_bfds; i; i = i->link_next)
1572 {
1573 bfd_signed_vma *local_got_refcounts;
1574 bfd_size_type j, cnt;
1575 Elf_Internal_Shdr *symtab_hdr;
1576
1577 local_got_refcounts = elf_local_got_refcounts (i);
1578 if (!local_got_refcounts)
1579 continue;
1580
1581 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1582 cnt = symtab_hdr->sh_info;
1583
1584 for (j = 0; j < cnt; ++j)
1585 {
28dbbc02
BW		 1586 /* If we saw any use of an IE model for this symbol, we can
1587 then optimize away GOT entries for any TLSDESC_FN relocs. */
1588 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1589 {
1590 bfd_signed_vma *tlsfunc_refcount
1591 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1592 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1593 local_got_refcounts[j] -= *tlsfunc_refcount;
1594 }
1595
e0001a05 1596 if (local_got_refcounts[j] > 0)
f0e6fdb2
BW		 1597 htab->srelgot->size += (local_got_refcounts[j]
1598 * sizeof (Elf32_External_Rela));
e0001a05
NC		 1599 }
1600 }
1601}
1602
1603
1604/* Set the sizes of the dynamic sections. */
1605
1606static bfd_boolean
7fa3d080
BW		 1607elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1608 struct bfd_link_info *info)
e0001a05 1609{
f0e6fdb2 1610 struct elf_xtensa_link_hash_table *htab;
e901de89
BW		 1611 bfd *dynobj, *abfd;
1612 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
e0001a05
NC		 1613 bfd_boolean relplt, relgot;
1614 int plt_entries, plt_chunks, chunk;
1615
1616 plt_entries = 0;
1617 plt_chunks = 0;
e0001a05 1618
f0e6fdb2 1619 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1620 if (htab == NULL)
1621 return FALSE;
1622
e0001a05
NC		 1623 dynobj = elf_hash_table (info)->dynobj;
1624 if (dynobj == NULL)
1625 abort ();
f0e6fdb2
BW		 1626 srelgot = htab->srelgot;
1627 srelplt = htab->srelplt;
e0001a05
NC		 1628
1629 if (elf_hash_table (info)->dynamic_sections_created)
1630 {
f0e6fdb2
BW		 1631 BFD_ASSERT (htab->srelgot != NULL
1632 && htab->srelplt != NULL
1633 && htab->sgot != NULL
1634 && htab->spltlittbl != NULL
1635 && htab->sgotloc != NULL);
1636
e0001a05 1637 /* Set the contents of the .interp section to the interpreter. */
893c4fe2 1638 if (info->executable)
e0001a05 1639 {
3d4d4302 1640 s = bfd_get_linker_section (dynobj, ".interp");
e0001a05
NC		 1641 if (s == NULL)
1642 abort ();
eea6121a 1643 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
e0001a05
NC		 1644 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1645 }
1646
1647 /* Allocate room for one word in ".got". */
f0e6fdb2 1648 htab->sgot->size = 4;
e0001a05 1649
f1ab2340
BW		 1650 /* Allocate space in ".rela.got" for literals that reference global
1651 symbols and space in ".rela.plt" for literals that have PLT
1652 entries. */
e0001a05 1653 elf_link_hash_traverse (elf_hash_table (info),
f1ab2340 1654 elf_xtensa_allocate_dynrelocs,
7fa3d080 1655 (void *) info);
e0001a05 1656
e0001a05
NC		 1657 /* If we are generating a shared object, we also need space in
1658 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1659 reference local symbols. */
1660 if (info->shared)
f0e6fdb2 1661 elf_xtensa_allocate_local_got_size (info);
e0001a05 1662
e0001a05
NC		 1663 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1664 each PLT entry, we need the PLT code plus a 4-byte literal.
1665 For each chunk of ".plt", we also need two more 4-byte
1666 literals, two corresponding entries in ".rela.got", and an
1667 8-byte entry in ".xt.lit.plt". */
f0e6fdb2 1668 spltlittbl = htab->spltlittbl;
eea6121a 1669 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 1670 plt_chunks =
1671 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1672
1673 /* Iterate over all the PLT chunks, including any extra sections
1674 created earlier because the initial count of PLT relocations
1675 was an overestimate. */
1676 for (chunk = 0;
f0e6fdb2 1677 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
e0001a05
NC		 1678 chunk++)
1679 {
1680 int chunk_entries;
1681
f0e6fdb2
BW		 1682 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1683 BFD_ASSERT (sgotplt != NULL);
e0001a05
NC		 1684
1685 if (chunk < plt_chunks - 1)
1686 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1687 else if (chunk == plt_chunks - 1)
1688 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1689 else
1690 chunk_entries = 0;
1691
1692 if (chunk_entries != 0)
1693 {
eea6121a
AM		 1694 sgotplt->size = 4 * (chunk_entries + 2);
1695 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1696 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1697 spltlittbl->size += 8;
e0001a05
NC		 1698 }
1699 else
1700 {
eea6121a
AM		 1701 sgotplt->size = 0;
1702 splt->size = 0;
e0001a05
NC		 1703 }
1704 }
e901de89
BW		 1705
1706 /* Allocate space in ".got.loc" to match the total size of all the
1707 literal tables. */
f0e6fdb2 1708 sgotloc = htab->sgotloc;
eea6121a 1709 sgotloc->size = spltlittbl->size;
e901de89
BW		 1710 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1711 {
1712 if (abfd->flags & DYNAMIC)
1713 continue;
1714 for (s = abfd->sections; s != NULL; s = s->next)
1715 {
dbaa2011 1716 if (! discarded_section (s)
b536dc1e
BW		 1717 && xtensa_is_littable_section (s)
1718 && s != spltlittbl)
eea6121a 1719 sgotloc->size += s->size;
e901de89
BW		 1720 }
1721 }
e0001a05
NC		 1722 }
1723
1724 /* Allocate memory for dynamic sections. */
1725 relplt = FALSE;
1726 relgot = FALSE;
1727 for (s = dynobj->sections; s != NULL; s = s->next)
1728 {
1729 const char *name;
e0001a05
NC		 1730
1731 if ((s->flags & SEC_LINKER_CREATED) == 0)
1732 continue;
1733
1734 /* It's OK to base decisions on the section name, because none
1735 of the dynobj section names depend upon the input files. */
1736 name = bfd_get_section_name (dynobj, s);
1737
0112cd26 1738 if (CONST_STRNEQ (name, ".rela"))
e0001a05 1739 {
c456f082 1740 if (s->size != 0)
e0001a05 1741 {
c456f082
AM		 1742 if (strcmp (name, ".rela.plt") == 0)
1743 relplt = TRUE;
1744 else if (strcmp (name, ".rela.got") == 0)
1745 relgot = TRUE;
1746
1747 /* We use the reloc_count field as a counter if we need
1748 to copy relocs into the output file. */
1749 s->reloc_count = 0;
e0001a05
NC		 1750 }
1751 }
0112cd26
NC		 1752 else if (! CONST_STRNEQ (name, ".plt.")
1753 && ! CONST_STRNEQ (name, ".got.plt.")
c456f082 1754 && strcmp (name, ".got") != 0
e0001a05
NC		 1755 && strcmp (name, ".plt") != 0
1756 && strcmp (name, ".got.plt") != 0
e901de89
BW		 1757 && strcmp (name, ".xt.lit.plt") != 0
1758 && strcmp (name, ".got.loc") != 0)
e0001a05
NC		 1759 {
1760 /* It's not one of our sections, so don't allocate space. */
1761 continue;
1762 }
1763
c456f082
AM		 1764 if (s->size == 0)
1765 {
1766 /* If we don't need this section, strip it from the output
1767 file. We must create the ".plt*" and ".got.plt*"
1768 sections in create_dynamic_sections and/or check_relocs
1769 based on a conservative estimate of the PLT relocation
1770 count, because the sections must be created before the
1771 linker maps input sections to output sections. The
1772 linker does that before size_dynamic_sections, where we
1773 compute the exact size of the PLT, so there may be more
1774 of these sections than are actually needed. */
1775 s->flags |= SEC_EXCLUDE;
1776 }
1777 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
e0001a05
NC		 1778 {
1779 /* Allocate memory for the section contents. */
eea6121a 1780 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c456f082 1781 if (s->contents == NULL)
e0001a05
NC		 1782 return FALSE;
1783 }
1784 }
1785
1786 if (elf_hash_table (info)->dynamic_sections_created)
1787 {
1788 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1789 known until finish_dynamic_sections, but we need to get the relocs
1790 in place before they are sorted. */
e0001a05
NC		 1791 for (chunk = 0; chunk < plt_chunks; chunk++)
1792 {
1793 Elf_Internal_Rela irela;
1794 bfd_byte *loc;
1795
1796 irela.r_offset = 0;
1797 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1798 irela.r_addend = 0;
1799
1800 loc = (srelgot->contents
1801 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1802 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1803 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1804 loc + sizeof (Elf32_External_Rela));
1805 srelgot->reloc_count += 2;
1806 }
1807
1808 /* Add some entries to the .dynamic section. We fill in the
1809 values later, in elf_xtensa_finish_dynamic_sections, but we
1810 must add the entries now so that we get the correct size for
1811 the .dynamic section. The DT_DEBUG entry is filled in by the
1812 dynamic linker and used by the debugger. */
1813#define add_dynamic_entry(TAG, VAL) \
5a580b3a 1814 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
e0001a05 1815
ba05963f 1816 if (info->executable)
e0001a05
NC		 1817 {
1818 if (!add_dynamic_entry (DT_DEBUG, 0))
1819 return FALSE;
1820 }
1821
1822 if (relplt)
1823 {
c243ad3b 1824 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
e0001a05
NC		 1825 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1826 || !add_dynamic_entry (DT_JMPREL, 0))
1827 return FALSE;
1828 }
1829
1830 if (relgot)
1831 {
1832 if (!add_dynamic_entry (DT_RELA, 0)
1833 || !add_dynamic_entry (DT_RELASZ, 0)
1834 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1835 return FALSE;
1836 }
1837
c243ad3b
BW		 1838 if (!add_dynamic_entry (DT_PLTGOT, 0)
1839 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
e0001a05
NC		 1840 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1841 return FALSE;
1842 }
1843#undef add_dynamic_entry
1844
1845 return TRUE;
1846}
1847
28dbbc02
BW		 1848static bfd_boolean
1849elf_xtensa_always_size_sections (bfd *output_bfd,
1850 struct bfd_link_info *info)
1851{
1852 struct elf_xtensa_link_hash_table *htab;
1853 asection *tls_sec;
1854
1855 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 1856 if (htab == NULL)
1857 return FALSE;
1858
28dbbc02
BW		 1859 tls_sec = htab->elf.tls_sec;
1860
1861 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1862 {
1863 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1864 struct bfd_link_hash_entry *bh = &tlsbase->root;
1865 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1866
1867 tlsbase->type = STT_TLS;
1868 if (!(_bfd_generic_link_add_one_symbol
1869 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1870 tls_sec, 0, NULL, FALSE,
1871 bed->collect, &bh)))
1872 return FALSE;
1873 tlsbase->def_regular = 1;
1874 tlsbase->other = STV_HIDDEN;
1875 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1876 }
1877
1878 return TRUE;
1879}
1880
e0001a05 1881\f
28dbbc02
BW		 1882/* Return the base VMA address which should be subtracted from real addresses
1883 when resolving @dtpoff relocation.
1884 This is PT_TLS segment p_vaddr. */
1885
1886static bfd_vma
1887dtpoff_base (struct bfd_link_info *info)
1888{
1889 /* If tls_sec is NULL, we should have signalled an error already. */
1890 if (elf_hash_table (info)->tls_sec == NULL)
1891 return 0;
1892 return elf_hash_table (info)->tls_sec->vma;
1893}
1894
1895/* Return the relocation value for @tpoff relocation
1896 if STT_TLS virtual address is ADDRESS. */
1897
1898static bfd_vma
1899tpoff (struct bfd_link_info *info, bfd_vma address)
1900{
1901 struct elf_link_hash_table *htab = elf_hash_table (info);
1902 bfd_vma base;
1903
1904 /* If tls_sec is NULL, we should have signalled an error already. */
1905 if (htab->tls_sec == NULL)
1906 return 0;
1907 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1908 return address - htab->tls_sec->vma + base;
1909}
1910
e0001a05
NC		 1911/* Perform the specified relocation. The instruction at (contents + address)
1912 is modified to set one operand to represent the value in "relocation". The
1913 operand position is determined by the relocation type recorded in the
1914 howto. */
1915
1916#define CALL_SEGMENT_BITS (30)
7fa3d080 1917#define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
e0001a05
NC		 1918
1919static bfd_reloc_status_type
7fa3d080
BW		 1920elf_xtensa_do_reloc (reloc_howto_type *howto,
1921 bfd *abfd,
1922 asection *input_section,
1923 bfd_vma relocation,
1924 bfd_byte *contents,
1925 bfd_vma address,
1926 bfd_boolean is_weak_undef,
1927 char **error_message)
e0001a05 1928{
43cd72b9 1929 xtensa_format fmt;
e0001a05 1930 xtensa_opcode opcode;
e0001a05 1931 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 1932 static xtensa_insnbuf ibuff = NULL;
1933 static xtensa_insnbuf sbuff = NULL;
1bbb5f21 1934 bfd_vma self_address;
43cd72b9
BW		 1935 bfd_size_type input_size;
1936 int opnd, slot;
e0001a05
NC		 1937 uint32 newval;
1938
43cd72b9
BW		 1939 if (!ibuff)
1940 {
1941 ibuff = xtensa_insnbuf_alloc (isa);
1942 sbuff = xtensa_insnbuf_alloc (isa);
1943 }
1944
1945 input_size = bfd_get_section_limit (abfd, input_section);
1946
1bbb5f21
BW		 1947 /* Calculate the PC address for this instruction. */
1948 self_address = (input_section->output_section->vma
1949 + input_section->output_offset
1950 + address);
1951
e0001a05
NC		 1952 switch (howto->type)
1953 {
1954 case R_XTENSA_NONE:
43cd72b9
BW		 1955 case R_XTENSA_DIFF8:
1956 case R_XTENSA_DIFF16:
1957 case R_XTENSA_DIFF32:
28dbbc02
BW		 1958 case R_XTENSA_TLS_FUNC:
1959 case R_XTENSA_TLS_ARG:
1960 case R_XTENSA_TLS_CALL:
e0001a05
NC		 1961 return bfd_reloc_ok;
1962
1963 case R_XTENSA_ASM_EXPAND:
1964 if (!is_weak_undef)
1965 {
1966 /* Check for windowed CALL across a 1GB boundary. */
91d6fa6a
NC		 1967 opcode = get_expanded_call_opcode (contents + address,
1968 input_size - address, 0);
e0001a05
NC		 1969 if (is_windowed_call_opcode (opcode))
1970 {
43cd72b9
BW		 1971 if ((self_address >> CALL_SEGMENT_BITS)
1972 != (relocation >> CALL_SEGMENT_BITS))
e0001a05
NC		 1973 {
1974 *error_message = "windowed longcall crosses 1GB boundary; "
1975 "return may fail";
1976 return bfd_reloc_dangerous;
1977 }
1978 }
1979 }
1980 return bfd_reloc_ok;
1981
1982 case R_XTENSA_ASM_SIMPLIFY:
43cd72b9 1983 {
e0001a05 1984 /* Convert the L32R/CALLX to CALL. */
43cd72b9
BW		 1985 bfd_reloc_status_type retval =
1986 elf_xtensa_do_asm_simplify (contents, address, input_size,
1987 error_message);
e0001a05 1988 if (retval != bfd_reloc_ok)
43cd72b9 1989 return bfd_reloc_dangerous;
e0001a05
NC		 1990
1991 /* The CALL needs to be relocated. Continue below for that part. */
1992 address += 3;
c46082c8 1993 self_address += 3;
43cd72b9 1994 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
e0001a05
NC		 1995 }
1996 break;
1997
1998 case R_XTENSA_32:
e0001a05
NC		 1999 {
2000 bfd_vma x;
2001 x = bfd_get_32 (abfd, contents + address);
2002 x = x + relocation;
2003 bfd_put_32 (abfd, x, contents + address);
2004 }
2005 return bfd_reloc_ok;
1bbb5f21
BW		 2006
2007 case R_XTENSA_32_PCREL:
2008 bfd_put_32 (abfd, relocation - self_address, contents + address);
2009 return bfd_reloc_ok;
28dbbc02
BW		 2010
2011 case R_XTENSA_PLT:
2012 case R_XTENSA_TLSDESC_FN:
2013 case R_XTENSA_TLSDESC_ARG:
2014 case R_XTENSA_TLS_DTPOFF:
2015 case R_XTENSA_TLS_TPOFF:
2016 bfd_put_32 (abfd, relocation, contents + address);
2017 return bfd_reloc_ok;
e0001a05
NC		 2018 }
2019
43cd72b9
BW		 2020 /* Only instruction slot-specific relocations handled below.... */
2021 slot = get_relocation_slot (howto->type);
2022 if (slot == XTENSA_UNDEFINED)
e0001a05 2023 {
43cd72b9 2024 *error_message = "unexpected relocation";
e0001a05
NC		 2025 return bfd_reloc_dangerous;
2026 }
2027
43cd72b9
BW		 2028 /* Read the instruction into a buffer and decode the opcode. */
2029 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2030 input_size - address);
2031 fmt = xtensa_format_decode (isa, ibuff);
2032 if (fmt == XTENSA_UNDEFINED)
e0001a05 2033 {
43cd72b9 2034 *error_message = "cannot decode instruction format";
e0001a05
NC		 2035 return bfd_reloc_dangerous;
2036 }
2037
43cd72b9 2038 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
e0001a05 2039
43cd72b9
BW		 2040 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2041 if (opcode == XTENSA_UNDEFINED)
e0001a05 2042 {
43cd72b9 2043 *error_message = "cannot decode instruction opcode";
e0001a05
NC		 2044 return bfd_reloc_dangerous;
2045 }
2046
43cd72b9
BW		 2047 /* Check for opcode-specific "alternate" relocations. */
2048 if (is_alt_relocation (howto->type))
2049 {
2050 if (opcode == get_l32r_opcode ())
2051 {
2052 /* Handle the special-case of non-PC-relative L32R instructions. */
2053 bfd *output_bfd = input_section->output_section->owner;
2054 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2055 if (!lit4_sec)
2056 {
2057 *error_message = "relocation references missing .lit4 section";
2058 return bfd_reloc_dangerous;
2059 }
2060 self_address = ((lit4_sec->vma & ~0xfff)
2061 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2062 newval = relocation;
2063 opnd = 1;
2064 }
2065 else if (opcode == get_const16_opcode ())
2066 {
2067 /* ALT used for high 16 bits. */
2068 newval = relocation >> 16;
2069 opnd = 1;
2070 }
2071 else
2072 {
2073 /* No other "alternate" relocations currently defined. */
2074 *error_message = "unexpected relocation";
2075 return bfd_reloc_dangerous;
2076 }
2077 }
2078 else /* Not an "alternate" relocation.... */
2079 {
2080 if (opcode == get_const16_opcode ())
2081 {
2082 newval = relocation & 0xffff;
2083 opnd = 1;
2084 }
2085 else
2086 {
2087 /* ...normal PC-relative relocation.... */
2088
2089 /* Determine which operand is being relocated. */
2090 opnd = get_relocation_opnd (opcode, howto->type);
2091 if (opnd == XTENSA_UNDEFINED)
2092 {
2093 *error_message = "unexpected relocation";
2094 return bfd_reloc_dangerous;
2095 }
2096
2097 if (!howto->pc_relative)
2098 {
2099 *error_message = "expected PC-relative relocation";
2100 return bfd_reloc_dangerous;
2101 }
e0001a05 2102
43cd72b9
BW		 2103 newval = relocation;
2104 }
2105 }
e0001a05 2106
43cd72b9
BW		 2107 /* Apply the relocation. */
2108 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2109 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2110 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2111 sbuff, newval))
e0001a05 2112 {
2db662be
BW		 2113 const char *opname = xtensa_opcode_name (isa, opcode);
2114 const char *msg;
2115
2116 msg = "cannot encode";
2117 if (is_direct_call_opcode (opcode))
2118 {
2119 if ((relocation & 0x3) != 0)
2120 msg = "misaligned call target";
2121 else
2122 msg = "call target out of range";
2123 }
2124 else if (opcode == get_l32r_opcode ())
2125 {
2126 if ((relocation & 0x3) != 0)
2127 msg = "misaligned literal target";
2128 else if (is_alt_relocation (howto->type))
2129 msg = "literal target out of range (too many literals)";
2130 else if (self_address > relocation)
2131 msg = "literal target out of range (try using text-section-literals)";
2132 else
2133 msg = "literal placed after use";
2134 }
2135
2136 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
e0001a05
NC		 2137 return bfd_reloc_dangerous;
2138 }
2139
43cd72b9 2140 /* Check for calls across 1GB boundaries. */
e0001a05
NC		 2141 if (is_direct_call_opcode (opcode)
2142 && is_windowed_call_opcode (opcode))
2143 {
43cd72b9
BW		 2144 if ((self_address >> CALL_SEGMENT_BITS)
2145 != (relocation >> CALL_SEGMENT_BITS))
e0001a05 2146 {
43cd72b9
BW		 2147 *error_message =
2148 "windowed call crosses 1GB boundary; return may fail";
e0001a05
NC		 2149 return bfd_reloc_dangerous;
2150 }
2151 }
2152
43cd72b9
BW		 2153 /* Write the modified instruction back out of the buffer. */
2154 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2155 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2156 input_size - address);
e0001a05
NC		 2157 return bfd_reloc_ok;
2158}
2159
2160
2db662be 2161static char *
7fa3d080 2162vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
e0001a05
NC		 2163{
2164 /* To reduce the size of the memory leak,
2165 we only use a single message buffer. */
2166 static bfd_size_type alloc_size = 0;
2167 static char *message = NULL;
2168 bfd_size_type orig_len, len = 0;
2169 bfd_boolean is_append;
2170
2171 VA_OPEN (ap, arglen);
2172 VA_FIXEDARG (ap, const char *, origmsg);
2173
2174 is_append = (origmsg == message);
2175
2176 orig_len = strlen (origmsg);
2177 len = orig_len + strlen (fmt) + arglen + 20;
2178 if (len > alloc_size)
2179 {
515ef31d 2180 message = (char *) bfd_realloc_or_free (message, len);
e0001a05
NC		 2181 alloc_size = len;
2182 }
515ef31d
NC		 2183 if (message != NULL)
2184 {
2185 if (!is_append)
2186 memcpy (message, origmsg, orig_len);
2187 vsprintf (message + orig_len, fmt, ap);
2188 }
e0001a05
NC		 2189 VA_CLOSE (ap);
2190 return message;
2191}
2192
2193
e0001a05
NC		 2194/* This function is registered as the "special_function" in the
2195 Xtensa howto for handling simplify operations.
2196 bfd_perform_relocation / bfd_install_relocation use it to
2197 perform (install) the specified relocation. Since this replaces the code
2198 in bfd_perform_relocation, it is basically an Xtensa-specific,
2199 stripped-down version of bfd_perform_relocation. */
2200
2201static bfd_reloc_status_type
7fa3d080
BW		 2202bfd_elf_xtensa_reloc (bfd *abfd,
2203 arelent *reloc_entry,
2204 asymbol *symbol,
2205 void *data,
2206 asection *input_section,
2207 bfd *output_bfd,
2208 char **error_message)
e0001a05
NC		 2209{
2210 bfd_vma relocation;
2211 bfd_reloc_status_type flag;
2212 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2213 bfd_vma output_base = 0;
2214 reloc_howto_type *howto = reloc_entry->howto;
2215 asection *reloc_target_output_section;
2216 bfd_boolean is_weak_undef;
2217
dd1a320b
BW		 2218 if (!xtensa_default_isa)
2219 xtensa_default_isa = xtensa_isa_init (0, 0);
2220
1049f94e 2221 /* ELF relocs are against symbols. If we are producing relocatable
e0001a05
NC		 2222 output, and the reloc is against an external symbol, the resulting
2223 reloc will also be against the same symbol. In such a case, we
2224 don't want to change anything about the way the reloc is handled,
2225 since it will all be done at final link time. This test is similar
2226 to what bfd_elf_generic_reloc does except that it lets relocs with
2227 howto->partial_inplace go through even if the addend is non-zero.
2228 (The real problem is that partial_inplace is set for XTENSA_32
2229 relocs to begin with, but that's a long story and there's little we
2230 can do about it now....) */
2231
7fa3d080 2232 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
e0001a05
NC		 2233 {
2234 reloc_entry->address += input_section->output_offset;
2235 return bfd_reloc_ok;
2236 }
2237
2238 /* Is the address of the relocation really within the section? */
07515404 2239 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
e0001a05
NC		 2240 return bfd_reloc_outofrange;
2241
4cc11e76 2242 /* Work out which section the relocation is targeted at and the
e0001a05
NC		 2243 initial relocation command value. */
2244
2245 /* Get symbol value. (Common symbols are special.) */
2246 if (bfd_is_com_section (symbol->section))
2247 relocation = 0;
2248 else
2249 relocation = symbol->value;
2250
2251 reloc_target_output_section = symbol->section->output_section;
2252
2253 /* Convert input-section-relative symbol value to absolute. */
2254 if ((output_bfd && !howto->partial_inplace)
2255 || reloc_target_output_section == NULL)
2256 output_base = 0;
2257 else
2258 output_base = reloc_target_output_section->vma;
2259
2260 relocation += output_base + symbol->section->output_offset;
2261
2262 /* Add in supplied addend. */
2263 relocation += reloc_entry->addend;
2264
2265 /* Here the variable relocation holds the final address of the
2266 symbol we are relocating against, plus any addend. */
2267 if (output_bfd)
2268 {
2269 if (!howto->partial_inplace)
2270 {
2271 /* This is a partial relocation, and we want to apply the relocation
2272 to the reloc entry rather than the raw data. Everything except
2273 relocations against section symbols has already been handled
2274 above. */
43cd72b9 2275
e0001a05
NC		 2276 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2277 reloc_entry->addend = relocation;
2278 reloc_entry->address += input_section->output_offset;
2279 return bfd_reloc_ok;
2280 }
2281 else
2282 {
2283 reloc_entry->address += input_section->output_offset;
2284 reloc_entry->addend = 0;
2285 }
2286 }
2287
2288 is_weak_undef = (bfd_is_und_section (symbol->section)
2289 && (symbol->flags & BSF_WEAK) != 0);
2290 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2291 (bfd_byte *) data, (bfd_vma) octets,
2292 is_weak_undef, error_message);
2293
2294 if (flag == bfd_reloc_dangerous)
2295 {
2296 /* Add the symbol name to the error message. */
2297 if (! *error_message)
2298 *error_message = "";
2299 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2300 strlen (symbol->name) + 17,
70961b9d
AM		 2301 symbol->name,
2302 (unsigned long) reloc_entry->addend);
e0001a05
NC		 2303 }
2304
2305 return flag;
2306}
2307
2308
2309/* Set up an entry in the procedure linkage table. */
2310
2311static bfd_vma
f0e6fdb2 2312elf_xtensa_create_plt_entry (struct bfd_link_info *info,
7fa3d080
BW		 2313 bfd *output_bfd,
2314 unsigned reloc_index)
e0001a05
NC		 2315{
2316 asection *splt, *sgotplt;
2317 bfd_vma plt_base, got_base;
2318 bfd_vma code_offset, lit_offset;
2319 int chunk;
2320
2321 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
f0e6fdb2
BW		 2322 splt = elf_xtensa_get_plt_section (info, chunk);
2323 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 2324 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2325
2326 plt_base = splt->output_section->vma + splt->output_offset;
2327 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2328
2329 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2330 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2331
2332 /* Fill in the literal entry. This is the offset of the dynamic
2333 relocation entry. */
2334 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2335 sgotplt->contents + lit_offset);
2336
2337 /* Fill in the entry in the procedure linkage table. */
2338 memcpy (splt->contents + code_offset,
2339 (bfd_big_endian (output_bfd)
2340 ? elf_xtensa_be_plt_entry
2341 : elf_xtensa_le_plt_entry),
2342 PLT_ENTRY_SIZE);
2343 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2344 plt_base + code_offset + 3),
2345 splt->contents + code_offset + 4);
2346 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2347 plt_base + code_offset + 6),
2348 splt->contents + code_offset + 7);
2349 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2350 plt_base + code_offset + 9),
2351 splt->contents + code_offset + 10);
2352
2353 return plt_base + code_offset;
2354}
2355
2356
28dbbc02
BW		 2357static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2358
2359static bfd_boolean
2360replace_tls_insn (Elf_Internal_Rela *rel,
2361 bfd *abfd,
2362 asection *input_section,
2363 bfd_byte *contents,
2364 bfd_boolean is_ld_model,
2365 char **error_message)
2366{
2367 static xtensa_insnbuf ibuff = NULL;
2368 static xtensa_insnbuf sbuff = NULL;
2369 xtensa_isa isa = xtensa_default_isa;
2370 xtensa_format fmt;
2371 xtensa_opcode old_op, new_op;
2372 bfd_size_type input_size;
2373 int r_type;
2374 unsigned dest_reg, src_reg;
2375
2376 if (ibuff == NULL)
2377 {
2378 ibuff = xtensa_insnbuf_alloc (isa);
2379 sbuff = xtensa_insnbuf_alloc (isa);
2380 }
2381
2382 input_size = bfd_get_section_limit (abfd, input_section);
2383
2384 /* Read the instruction into a buffer and decode the opcode. */
2385 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2386 input_size - rel->r_offset);
2387 fmt = xtensa_format_decode (isa, ibuff);
2388 if (fmt == XTENSA_UNDEFINED)
2389 {
2390 *error_message = "cannot decode instruction format";
2391 return FALSE;
2392 }
2393
2394 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2395 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2396
2397 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2398 if (old_op == XTENSA_UNDEFINED)
2399 {
2400 *error_message = "cannot decode instruction opcode";
2401 return FALSE;
2402 }
2403
2404 r_type = ELF32_R_TYPE (rel->r_info);
2405 switch (r_type)
2406 {
2407 case R_XTENSA_TLS_FUNC:
2408 case R_XTENSA_TLS_ARG:
2409 if (old_op != get_l32r_opcode ()
2410 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2411 sbuff, &dest_reg) != 0)
2412 {
2413 *error_message = "cannot extract L32R destination for TLS access";
2414 return FALSE;
2415 }
2416 break;
2417
2418 case R_XTENSA_TLS_CALL:
2419 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2420 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2421 sbuff, &src_reg) != 0)
2422 {
2423 *error_message = "cannot extract CALLXn operands for TLS access";
2424 return FALSE;
2425 }
2426 break;
2427
2428 default:
2429 abort ();
2430 }
2431
2432 if (is_ld_model)
2433 {
2434 switch (r_type)
2435 {
2436 case R_XTENSA_TLS_FUNC:
2437 case R_XTENSA_TLS_ARG:
2438 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2439 versions of Xtensa). */
2440 new_op = xtensa_opcode_lookup (isa, "nop");
2441 if (new_op == XTENSA_UNDEFINED)
2442 {
2443 new_op = xtensa_opcode_lookup (isa, "or");
2444 if (new_op == XTENSA_UNDEFINED
2445 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2446 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2447 sbuff, 1) != 0
2448 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2449 sbuff, 1) != 0
2450 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2451 sbuff, 1) != 0)
2452 {
2453 *error_message = "cannot encode OR for TLS access";
2454 return FALSE;
2455 }
2456 }
2457 else
2458 {
2459 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2460 {
2461 *error_message = "cannot encode NOP for TLS access";
2462 return FALSE;
2463 }
2464 }
2465 break;
2466
2467 case R_XTENSA_TLS_CALL:
2468 /* Read THREADPTR into the CALLX's return value register. */
2469 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2470 if (new_op == XTENSA_UNDEFINED
2471 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2472 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2473 sbuff, dest_reg + 2) != 0)
2474 {
2475 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2476 return FALSE;
2477 }
2478 break;
2479 }
2480 }
2481 else
2482 {
2483 switch (r_type)
2484 {
2485 case R_XTENSA_TLS_FUNC:
2486 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2487 if (new_op == XTENSA_UNDEFINED
2488 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2489 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2490 sbuff, dest_reg) != 0)
2491 {
2492 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2493 return FALSE;
2494 }
2495 break;
2496
2497 case R_XTENSA_TLS_ARG:
2498 /* Nothing to do. Keep the original L32R instruction. */
2499 return TRUE;
2500
2501 case R_XTENSA_TLS_CALL:
2502 /* Add the CALLX's src register (holding the THREADPTR value)
2503 to the first argument register (holding the offset) and put
2504 the result in the CALLX's return value register. */
2505 new_op = xtensa_opcode_lookup (isa, "add");
2506 if (new_op == XTENSA_UNDEFINED
2507 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2508 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2509 sbuff, dest_reg + 2) != 0
2510 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2511 sbuff, dest_reg + 2) != 0
2512 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2513 sbuff, src_reg) != 0)
2514 {
2515 *error_message = "cannot encode ADD for TLS access";
2516 return FALSE;
2517 }
2518 break;
2519 }
2520 }
2521
2522 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2523 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2524 input_size - rel->r_offset);
2525
2526 return TRUE;
2527}
2528
2529
2530#define IS_XTENSA_TLS_RELOC(R_TYPE) \
2531 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2532 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2533 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2534 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2535 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2536 || (R_TYPE) == R_XTENSA_TLS_ARG \
2537 || (R_TYPE) == R_XTENSA_TLS_CALL)
2538
e0001a05 2539/* Relocate an Xtensa ELF section. This is invoked by the linker for
1049f94e 2540 both relocatable and final links. */
e0001a05
NC		 2541
2542static bfd_boolean
7fa3d080
BW		 2543elf_xtensa_relocate_section (bfd *output_bfd,
2544 struct bfd_link_info *info,
2545 bfd *input_bfd,
2546 asection *input_section,
2547 bfd_byte *contents,
2548 Elf_Internal_Rela *relocs,
2549 Elf_Internal_Sym *local_syms,
2550 asection **local_sections)
e0001a05 2551{
f0e6fdb2 2552 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 2553 Elf_Internal_Shdr *symtab_hdr;
2554 Elf_Internal_Rela *rel;
2555 Elf_Internal_Rela *relend;
2556 struct elf_link_hash_entry **sym_hashes;
88d65ad6
BW		 2557 property_table_entry *lit_table = 0;
2558 int ltblsize = 0;
28dbbc02 2559 char *local_got_tls_types;
e0001a05 2560 char *error_message = NULL;
43cd72b9 2561 bfd_size_type input_size;
28dbbc02 2562 int tls_type;
e0001a05 2563
43cd72b9
BW		 2564 if (!xtensa_default_isa)
2565 xtensa_default_isa = xtensa_isa_init (0, 0);
e0001a05 2566
28dbbc02
BW		 2567 BFD_ASSERT (is_xtensa_elf (input_bfd));
2568
f0e6fdb2 2569 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 2570 if (htab == NULL)
2571 return FALSE;
2572
e0001a05
NC		 2573 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2574 sym_hashes = elf_sym_hashes (input_bfd);
28dbbc02 2575 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
e0001a05 2576
88d65ad6
BW		 2577 if (elf_hash_table (info)->dynamic_sections_created)
2578 {
2579 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
43cd72b9
BW		 2580 &lit_table, XTENSA_LIT_SEC_NAME,
2581 TRUE);
88d65ad6
BW		 2582 if (ltblsize < 0)
2583 return FALSE;
2584 }
2585
43cd72b9
BW		 2586 input_size = bfd_get_section_limit (input_bfd, input_section);
2587
e0001a05
NC		 2588 rel = relocs;
2589 relend = relocs + input_section->reloc_count;
2590 for (; rel < relend; rel++)
2591 {
2592 int r_type;
2593 reloc_howto_type *howto;
2594 unsigned long r_symndx;
2595 struct elf_link_hash_entry *h;
2596 Elf_Internal_Sym *sym;
28dbbc02
BW		 2597 char sym_type;
2598 const char *name;
e0001a05
NC		 2599 asection *sec;
2600 bfd_vma relocation;
2601 bfd_reloc_status_type r;
2602 bfd_boolean is_weak_undef;
2603 bfd_boolean unresolved_reloc;
9b8c98a4 2604 bfd_boolean warned;
28dbbc02 2605 bfd_boolean dynamic_symbol;
e0001a05
NC		 2606
2607 r_type = ELF32_R_TYPE (rel->r_info);
2608 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2609 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2610 continue;
2611
2612 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2613 {
2614 bfd_set_error (bfd_error_bad_value);
2615 return FALSE;
2616 }
2617 howto = &elf_howto_table[r_type];
2618
2619 r_symndx = ELF32_R_SYM (rel->r_info);
2620
ab96bf03
AM		 2621 h = NULL;
2622 sym = NULL;
2623 sec = NULL;
2624 is_weak_undef = FALSE;
2625 unresolved_reloc = FALSE;
2626 warned = FALSE;
2627
2628 if (howto->partial_inplace && !info->relocatable)
2629 {
2630 /* Because R_XTENSA_32 was made partial_inplace to fix some
2631 problems with DWARF info in partial links, there may be
2632 an addend stored in the contents. Take it out of there
2633 and move it back into the addend field of the reloc. */
2634 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2635 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2636 }
2637
2638 if (r_symndx < symtab_hdr->sh_info)
2639 {
2640 sym = local_syms + r_symndx;
28dbbc02 2641 sym_type = ELF32_ST_TYPE (sym->st_info);
ab96bf03
AM		 2642 sec = local_sections[r_symndx];
2643 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2644 }
2645 else
2646 {
2647 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2648 r_symndx, symtab_hdr, sym_hashes,
2649 h, sec, relocation,
2650 unresolved_reloc, warned);
2651
2652 if (relocation == 0
2653 && !unresolved_reloc
2654 && h->root.type == bfd_link_hash_undefweak)
2655 is_weak_undef = TRUE;
28dbbc02
BW		 2656
2657 sym_type = h->type;
ab96bf03
AM		 2658 }
2659
dbaa2011 2660 if (sec != NULL && discarded_section (sec))
e4067dbb 2661 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 2662 rel, 1, relend, howto, 0, contents);
ab96bf03 2663
1049f94e 2664 if (info->relocatable)
e0001a05 2665 {
7aa09196
SA		 2666 bfd_vma dest_addr;
2667 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2668
43cd72b9 2669 /* This is a relocatable link.
e0001a05
NC		 2670 1) If the reloc is against a section symbol, adjust
2671 according to the output section.
2672 2) If there is a new target for this relocation,
2673 the new target will be in the same output section.
2674 We adjust the relocation by the output section
2675 difference. */
2676
2677 if (relaxing_section)
2678 {
2679 /* Check if this references a section in another input file. */
43cd72b9
BW		 2680 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2681 contents))
2682 return FALSE;
e0001a05
NC		 2683 }
2684
7aa09196
SA		 2685 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2686 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2687
43cd72b9 2688 if (r_type == R_XTENSA_ASM_SIMPLIFY)
e0001a05 2689 {
91d6fa6a 2690 error_message = NULL;
e0001a05
NC		 2691 /* Convert ASM_SIMPLIFY into the simpler relocation
2692 so that they never escape a relaxing link. */
43cd72b9
BW		 2693 r = contract_asm_expansion (contents, input_size, rel,
2694 &error_message);
2695 if (r != bfd_reloc_ok)
2696 {
2697 if (!((*info->callbacks->reloc_dangerous)
2698 (info, error_message, input_bfd, input_section,
2699 rel->r_offset)))
2700 return FALSE;
2701 }
e0001a05
NC		 2702 r_type = ELF32_R_TYPE (rel->r_info);
2703 }
2704
1049f94e 2705 /* This is a relocatable link, so we don't have to change
e0001a05
NC		 2706 anything unless the reloc is against a section symbol,
2707 in which case we have to adjust according to where the
2708 section symbol winds up in the output section. */
2709 if (r_symndx < symtab_hdr->sh_info)
2710 {
2711 sym = local_syms + r_symndx;
2712 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2713 {
2714 sec = local_sections[r_symndx];
2715 rel->r_addend += sec->output_offset + sym->st_value;
2716 }
2717 }
2718
2719 /* If there is an addend with a partial_inplace howto,
2720 then move the addend to the contents. This is a hack
1049f94e 2721 to work around problems with DWARF in relocatable links
e0001a05
NC		 2722 with some previous version of BFD. Now we can't easily get
2723 rid of the hack without breaking backward compatibility.... */
7aa09196
SA		 2724 r = bfd_reloc_ok;
2725 howto = &elf_howto_table[r_type];
2726 if (howto->partial_inplace && rel->r_addend)
2727 {
2728 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2729 rel->r_addend, contents,
2730 rel->r_offset, FALSE,
2731 &error_message);
2732 rel->r_addend = 0;
2733 }
2734 else
e0001a05 2735 {
7aa09196
SA		 2736 /* Put the correct bits in the target instruction, even
2737 though the relocation will still be present in the output
2738 file. This makes disassembly clearer, as well as
2739 allowing loadable kernel modules to work without needing
2740 relocations on anything other than calls and l32r's. */
2741
2742 /* If it is not in the same section, there is nothing we can do. */
2743 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2744 sym_sec->output_section == input_section->output_section)
e0001a05
NC		 2745 {
2746 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
7aa09196 2747 dest_addr, contents,
e0001a05
NC		 2748 rel->r_offset, FALSE,
2749 &error_message);
e0001a05
NC		 2750 }
2751 }
7aa09196
SA		 2752 if (r != bfd_reloc_ok)
2753 {
2754 if (!((*info->callbacks->reloc_dangerous)
2755 (info, error_message, input_bfd, input_section,
2756 rel->r_offset)))
2757 return FALSE;
2758 }
e0001a05 2759
1049f94e 2760 /* Done with work for relocatable link; continue with next reloc. */
e0001a05
NC		 2761 continue;
2762 }
2763
2764 /* This is a final link. */
2765
e0001a05
NC		 2766 if (relaxing_section)
2767 {
2768 /* Check if this references a section in another input file. */
43cd72b9
BW		 2769 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2770 &relocation);
e0001a05
NC		 2771 }
2772
2773 /* Sanity check the address. */
43cd72b9 2774 if (rel->r_offset >= input_size
e0001a05
NC		 2775 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2776 {
43cd72b9
BW		 2777 (*_bfd_error_handler)
2778 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2779 input_bfd, input_section, rel->r_offset, input_size);
e0001a05
NC		 2780 bfd_set_error (bfd_error_bad_value);
2781 return FALSE;
2782 }
2783
28dbbc02
BW		 2784 if (h != NULL)
2785 name = h->root.root.string;
2786 else
e0001a05 2787 {
28dbbc02
BW		 2788 name = (bfd_elf_string_from_elf_section
2789 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2790 if (name == NULL || *name == '\0')
2791 name = bfd_section_name (input_bfd, sec);
2792 }
e0001a05 2793
cf35638d 2794 if (r_symndx != STN_UNDEF
28dbbc02
BW		 2795 && r_type != R_XTENSA_NONE
2796 && (h == NULL
2797 || h->root.type == bfd_link_hash_defined
2798 || h->root.type == bfd_link_hash_defweak)
2799 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2800 {
2801 (*_bfd_error_handler)
2802 ((sym_type == STT_TLS
2803 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2804 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2805 input_bfd,
2806 input_section,
2807 (long) rel->r_offset,
2808 howto->name,
2809 name);
2810 }
2811
2812 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2813
2814 tls_type = GOT_UNKNOWN;
2815 if (h)
2816 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2817 else if (local_got_tls_types)
2818 tls_type = local_got_tls_types [r_symndx];
2819
2820 switch (r_type)
2821 {
2822 case R_XTENSA_32:
2823 case R_XTENSA_PLT:
2824 if (elf_hash_table (info)->dynamic_sections_created
2825 && (input_section->flags & SEC_ALLOC) != 0
2826 && (dynamic_symbol || info->shared))
e0001a05
NC		 2827 {
2828 Elf_Internal_Rela outrel;
2829 bfd_byte *loc;
2830 asection *srel;
2831
2832 if (dynamic_symbol && r_type == R_XTENSA_PLT)
f0e6fdb2 2833 srel = htab->srelplt;
e0001a05 2834 else
f0e6fdb2 2835 srel = htab->srelgot;
e0001a05
NC		 2836
2837 BFD_ASSERT (srel != NULL);
2838
2839 outrel.r_offset =
2840 _bfd_elf_section_offset (output_bfd, info,
2841 input_section, rel->r_offset);
2842
2843 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2844 memset (&outrel, 0, sizeof outrel);
2845 else
2846 {
f0578e28
BW		 2847 outrel.r_offset += (input_section->output_section->vma
2848 + input_section->output_offset);
e0001a05 2849
88d65ad6
BW		 2850 /* Complain if the relocation is in a read-only section
2851 and not in a literal pool. */
2852 if ((input_section->flags & SEC_READONLY) != 0
2853 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
3ba3bc8c 2854 outrel.r_offset))
88d65ad6
BW		 2855 {
2856 error_message =
2857 _("dynamic relocation in read-only section");
2858 if (!((*info->callbacks->reloc_dangerous)
2859 (info, error_message, input_bfd, input_section,
2860 rel->r_offset)))
2861 return FALSE;
2862 }
2863
e0001a05
NC		 2864 if (dynamic_symbol)
2865 {
2866 outrel.r_addend = rel->r_addend;
2867 rel->r_addend = 0;
2868
2869 if (r_type == R_XTENSA_32)
2870 {
2871 outrel.r_info =
2872 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2873 relocation = 0;
2874 }
2875 else /* r_type == R_XTENSA_PLT */
2876 {
2877 outrel.r_info =
2878 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2879
2880 /* Create the PLT entry and set the initial
2881 contents of the literal entry to the address of
2882 the PLT entry. */
43cd72b9 2883 relocation =
f0e6fdb2 2884 elf_xtensa_create_plt_entry (info, output_bfd,
e0001a05
NC		 2885 srel->reloc_count);
2886 }
2887 unresolved_reloc = FALSE;
2888 }
2889 else
2890 {
2891 /* Generate a RELATIVE relocation. */
2892 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2893 outrel.r_addend = 0;
2894 }
2895 }
2896
2897 loc = (srel->contents
2898 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2899 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2900 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
eea6121a 2901 <= srel->size);
e0001a05 2902 }
d9ab3f29
BW		 2903 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2904 {
2905 /* This should only happen for non-PIC code, which is not
2906 supposed to be used on systems with dynamic linking.
2907 Just ignore these relocations. */
2908 continue;
2909 }
28dbbc02
BW		 2910 break;
2911
2912 case R_XTENSA_TLS_TPOFF:
2913 /* Switch to LE model for local symbols in an executable. */
2914 if (! info->shared && ! dynamic_symbol)
2915 {
2916 relocation = tpoff (info, relocation);
2917 break;
2918 }
2919 /* fall through */
2920
2921 case R_XTENSA_TLSDESC_FN:
2922 case R_XTENSA_TLSDESC_ARG:
2923 {
2924 if (r_type == R_XTENSA_TLSDESC_FN)
2925 {
2926 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2927 r_type = R_XTENSA_NONE;
2928 }
2929 else if (r_type == R_XTENSA_TLSDESC_ARG)
2930 {
2931 if (info->shared)
2932 {
2933 if ((tls_type & GOT_TLS_IE) != 0)
2934 r_type = R_XTENSA_TLS_TPOFF;
2935 }
2936 else
2937 {
2938 r_type = R_XTENSA_TLS_TPOFF;
2939 if (! dynamic_symbol)
2940 {
2941 relocation = tpoff (info, relocation);
2942 break;
2943 }
2944 }
2945 }
2946
2947 if (r_type == R_XTENSA_NONE)
2948 /* Nothing to do here; skip to the next reloc. */
2949 continue;
2950
2951 if (! elf_hash_table (info)->dynamic_sections_created)
2952 {
2953 error_message =
2954 _("TLS relocation invalid without dynamic sections");
2955 if (!((*info->callbacks->reloc_dangerous)
2956 (info, error_message, input_bfd, input_section,
2957 rel->r_offset)))
2958 return FALSE;
2959 }
2960 else
2961 {
2962 Elf_Internal_Rela outrel;
2963 bfd_byte *loc;
2964 asection *srel = htab->srelgot;
2965 int indx;
2966
2967 outrel.r_offset = (input_section->output_section->vma
2968 + input_section->output_offset
2969 + rel->r_offset);
2970
2971 /* Complain if the relocation is in a read-only section
2972 and not in a literal pool. */
2973 if ((input_section->flags & SEC_READONLY) != 0
2974 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2975 outrel.r_offset))
2976 {
2977 error_message =
2978 _("dynamic relocation in read-only section");
2979 if (!((*info->callbacks->reloc_dangerous)
2980 (info, error_message, input_bfd, input_section,
2981 rel->r_offset)))
2982 return FALSE;
2983 }
2984
2985 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2986 if (indx == 0)
2987 outrel.r_addend = relocation - dtpoff_base (info);
2988 else
2989 outrel.r_addend = 0;
2990 rel->r_addend = 0;
2991
2992 outrel.r_info = ELF32_R_INFO (indx, r_type);
2993 relocation = 0;
2994 unresolved_reloc = FALSE;
2995
2996 BFD_ASSERT (srel);
2997 loc = (srel->contents
2998 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2999 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3000 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3001 <= srel->size);
3002 }
3003 }
3004 break;
3005
3006 case R_XTENSA_TLS_DTPOFF:
3007 if (! info->shared)
3008 /* Switch from LD model to LE model. */
3009 relocation = tpoff (info, relocation);
3010 else
3011 relocation -= dtpoff_base (info);
3012 break;
3013
3014 case R_XTENSA_TLS_FUNC:
3015 case R_XTENSA_TLS_ARG:
3016 case R_XTENSA_TLS_CALL:
3017 /* Check if optimizing to IE or LE model. */
3018 if ((tls_type & GOT_TLS_IE) != 0)
3019 {
3020 bfd_boolean is_ld_model =
3021 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3022 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3023 is_ld_model, &error_message))
3024 {
3025 if (!((*info->callbacks->reloc_dangerous)
3026 (info, error_message, input_bfd, input_section,
3027 rel->r_offset)))
3028 return FALSE;
3029 }
3030
3031 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3032 {
3033 /* Skip subsequent relocations on the same instruction. */
3034 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3035 rel++;
3036 }
3037 }
3038 continue;
3039
3040 default:
3041 if (elf_hash_table (info)->dynamic_sections_created
3042 && dynamic_symbol && (is_operand_relocation (r_type)
3043 || r_type == R_XTENSA_32_PCREL))
3044 {
3045 error_message =
3046 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3047 strlen (name) + 2, name);
3048 if (!((*info->callbacks->reloc_dangerous)
3049 (info, error_message, input_bfd, input_section,
3050 rel->r_offset)))
3051 return FALSE;
3052 continue;
3053 }
3054 break;
e0001a05
NC		 3055 }
3056
3057 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3058 because such sections are not SEC_ALLOC and thus ld.so will
3059 not process them. */
3060 if (unresolved_reloc
3061 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 3062 && h->def_dynamic)
3063 && _bfd_elf_section_offset (output_bfd, info, input_section,
3064 rel->r_offset) != (bfd_vma) -1)
bf1747de
BW		 3065 {
3066 (*_bfd_error_handler)
3067 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3068 input_bfd,
3069 input_section,
3070 (long) rel->r_offset,
3071 howto->name,
28dbbc02 3072 name);
bf1747de
BW		 3073 return FALSE;
3074 }
e0001a05 3075
28dbbc02
BW		 3076 /* TLS optimizations may have changed r_type; update "howto". */
3077 howto = &elf_howto_table[r_type];
3078
e0001a05
NC		 3079 /* There's no point in calling bfd_perform_relocation here.
3080 Just go directly to our "special function". */
3081 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3082 relocation + rel->r_addend,
3083 contents, rel->r_offset, is_weak_undef,
3084 &error_message);
43cd72b9 3085
9b8c98a4 3086 if (r != bfd_reloc_ok && !warned)
e0001a05 3087 {
43cd72b9 3088 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
7fa3d080 3089 BFD_ASSERT (error_message != NULL);
e0001a05 3090
28dbbc02
BW		 3091 if (rel->r_addend == 0)
3092 error_message = vsprint_msg (error_message, ": %s",
3093 strlen (name) + 2, name);
e0001a05 3094 else
28dbbc02
BW		 3095 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3096 strlen (name) + 22,
3097 name, (int) rel->r_addend);
43cd72b9 3098
e0001a05
NC		 3099 if (!((*info->callbacks->reloc_dangerous)
3100 (info, error_message, input_bfd, input_section,
3101 rel->r_offset)))
3102 return FALSE;
3103 }
3104 }
3105
88d65ad6
BW		 3106 if (lit_table)
3107 free (lit_table);
3108
3ba3bc8c
BW		 3109 input_section->reloc_done = TRUE;
3110
e0001a05
NC		 3111 return TRUE;
3112}
3113
3114
3115/* Finish up dynamic symbol handling. There's not much to do here since
3116 the PLT and GOT entries are all set up by relocate_section. */
3117
3118static bfd_boolean
7fa3d080
BW		 3119elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3120 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3121 struct elf_link_hash_entry *h,
3122 Elf_Internal_Sym *sym)
e0001a05 3123{
bf1747de 3124 if (h->needs_plt && !h->def_regular)
e0001a05
NC		 3125 {
3126 /* Mark the symbol as undefined, rather than as defined in
3127 the .plt section. Leave the value alone. */
3128 sym->st_shndx = SHN_UNDEF;
bf1747de
BW		 3129 /* If the symbol is weak, we do need to clear the value.
3130 Otherwise, the PLT entry would provide a definition for
3131 the symbol even if the symbol wasn't defined anywhere,
3132 and so the symbol would never be NULL. */
3133 if (!h->ref_regular_nonweak)
3134 sym->st_value = 0;
e0001a05
NC		 3135 }
3136
3137 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
9637f6ef 3138 if (h == elf_hash_table (info)->hdynamic
22edb2f1 3139 || h == elf_hash_table (info)->hgot)
e0001a05
NC		 3140 sym->st_shndx = SHN_ABS;
3141
3142 return TRUE;
3143}
3144
3145
3146/* Combine adjacent literal table entries in the output. Adjacent
3147 entries within each input section may have been removed during
3148 relaxation, but we repeat the process here, even though it's too late
3149 to shrink the output section, because it's important to minimize the
3150 number of literal table entries to reduce the start-up work for the
3151 runtime linker. Returns the number of remaining table entries or -1
3152 on error. */
3153
3154static int
7fa3d080
BW		 3155elf_xtensa_combine_prop_entries (bfd *output_bfd,
3156 asection *sxtlit,
3157 asection *sgotloc)
e0001a05 3158{
e0001a05
NC		 3159 bfd_byte *contents;
3160 property_table_entry *table;
e901de89 3161 bfd_size_type section_size, sgotloc_size;
e0001a05
NC		 3162 bfd_vma offset;
3163 int n, m, num;
3164
eea6121a 3165 section_size = sxtlit->size;
e0001a05
NC		 3166 BFD_ASSERT (section_size % 8 == 0);
3167 num = section_size / 8;
3168
eea6121a 3169 sgotloc_size = sgotloc->size;
e901de89 3170 if (sgotloc_size != section_size)
b536dc1e
BW		 3171 {
3172 (*_bfd_error_handler)
43cd72b9 3173 (_("internal inconsistency in size of .got.loc section"));
b536dc1e
BW		 3174 return -1;
3175 }
e901de89 3176
eea6121a
AM		 3177 table = bfd_malloc (num * sizeof (property_table_entry));
3178 if (table == 0)
e0001a05
NC		 3179 return -1;
3180
3181 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3182 propagates to the output section, where it doesn't really apply and
eea6121a 3183 where it breaks the following call to bfd_malloc_and_get_section. */
e901de89 3184 sxtlit->flags &= ~SEC_IN_MEMORY;
e0001a05 3185
eea6121a
AM		 3186 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3187 {
3188 if (contents != 0)
3189 free (contents);
3190 free (table);
3191 return -1;
3192 }
e0001a05
NC		 3193
3194 /* There should never be any relocations left at this point, so this
3195 is quite a bit easier than what is done during relaxation. */
3196
3197 /* Copy the raw contents into a property table array and sort it. */
3198 offset = 0;
3199 for (n = 0; n < num; n++)
3200 {
3201 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3202 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3203 offset += 8;
3204 }
3205 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3206
3207 for (n = 0; n < num; n++)
3208 {
91d6fa6a 3209 bfd_boolean remove_entry = FALSE;
e0001a05
NC		 3210
3211 if (table[n].size == 0)
91d6fa6a
NC		 3212 remove_entry = TRUE;
3213 else if (n > 0
3214 && (table[n-1].address + table[n-1].size == table[n].address))
e0001a05
NC		 3215 {
3216 table[n-1].size += table[n].size;
91d6fa6a 3217 remove_entry = TRUE;
e0001a05
NC		 3218 }
3219
91d6fa6a 3220 if (remove_entry)
e0001a05
NC		 3221 {
3222 for (m = n; m < num - 1; m++)
3223 {
3224 table[m].address = table[m+1].address;
3225 table[m].size = table[m+1].size;
3226 }
3227
3228 n--;
3229 num--;
3230 }
3231 }
3232
3233 /* Copy the data back to the raw contents. */
3234 offset = 0;
3235 for (n = 0; n < num; n++)
3236 {
3237 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3238 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3239 offset += 8;
3240 }
3241
3242 /* Clear the removed bytes. */
3243 if ((bfd_size_type) (num * 8) < section_size)
b54d4b07 3244 memset (&contents[num * 8], 0, section_size - num * 8);
e0001a05 3245
e901de89
BW		 3246 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3247 section_size))
e0001a05
NC		 3248 return -1;
3249
e901de89
BW		 3250 /* Copy the contents to ".got.loc". */
3251 memcpy (sgotloc->contents, contents, section_size);
3252
e0001a05 3253 free (contents);
b614a702 3254 free (table);
e0001a05
NC		 3255 return num;
3256}
3257
3258
3259/* Finish up the dynamic sections. */
3260
3261static bfd_boolean
7fa3d080
BW		 3262elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3263 struct bfd_link_info *info)
e0001a05 3264{
f0e6fdb2 3265 struct elf_xtensa_link_hash_table *htab;
e0001a05 3266 bfd *dynobj;
e901de89 3267 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
e0001a05 3268 Elf32_External_Dyn *dyncon, *dynconend;
d9ab3f29 3269 int num_xtlit_entries = 0;
e0001a05
NC		 3270
3271 if (! elf_hash_table (info)->dynamic_sections_created)
3272 return TRUE;
3273
f0e6fdb2 3274 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 3275 if (htab == NULL)
3276 return FALSE;
3277
e0001a05 3278 dynobj = elf_hash_table (info)->dynobj;
3d4d4302 3279 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
e0001a05
NC		 3280 BFD_ASSERT (sdyn != NULL);
3281
3282 /* Set the first entry in the global offset table to the address of
3283 the dynamic section. */
f0e6fdb2 3284 sgot = htab->sgot;
e0001a05
NC		 3285 if (sgot)
3286 {
eea6121a 3287 BFD_ASSERT (sgot->size == 4);
e0001a05 3288 if (sdyn == NULL)
7fa3d080 3289 bfd_put_32 (output_bfd, 0, sgot->contents);
e0001a05
NC		 3290 else
3291 bfd_put_32 (output_bfd,
3292 sdyn->output_section->vma + sdyn->output_offset,
3293 sgot->contents);
3294 }
3295
f0e6fdb2 3296 srelplt = htab->srelplt;
7fa3d080 3297 if (srelplt && srelplt->size != 0)
e0001a05
NC		 3298 {
3299 asection *sgotplt, *srelgot, *spltlittbl;
3300 int chunk, plt_chunks, plt_entries;
3301 Elf_Internal_Rela irela;
3302 bfd_byte *loc;
3303 unsigned rtld_reloc;
3304
f0e6fdb2
BW		 3305 srelgot = htab->srelgot;
3306 spltlittbl = htab->spltlittbl;
3307 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
e0001a05
NC		 3308
3309 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3310 of them follow immediately after.... */
3311 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3312 {
3313 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3314 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3315 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3316 break;
3317 }
3318 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3319
eea6121a 3320 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 3321 plt_chunks =
3322 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3323
3324 for (chunk = 0; chunk < plt_chunks; chunk++)
3325 {
3326 int chunk_entries = 0;
3327
f0e6fdb2 3328 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 3329 BFD_ASSERT (sgotplt != NULL);
3330
3331 /* Emit special RTLD relocations for the first two entries in
3332 each chunk of the .got.plt section. */
3333
3334 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3335 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3336 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3337 irela.r_offset = (sgotplt->output_section->vma
3338 + sgotplt->output_offset);
3339 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3340 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3341 rtld_reloc += 1;
3342 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3343
3344 /* Next literal immediately follows the first. */
3345 loc += sizeof (Elf32_External_Rela);
3346 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3347 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3348 irela.r_offset = (sgotplt->output_section->vma
3349 + sgotplt->output_offset + 4);
3350 /* Tell rtld to set value to object's link map. */
3351 irela.r_addend = 2;
3352 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3353 rtld_reloc += 1;
3354 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3355
3356 /* Fill in the literal table. */
3357 if (chunk < plt_chunks - 1)
3358 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3359 else
3360 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3361
eea6121a 3362 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
e0001a05
NC		 3363 bfd_put_32 (output_bfd,
3364 sgotplt->output_section->vma + sgotplt->output_offset,
3365 spltlittbl->contents + (chunk * 8) + 0);
3366 bfd_put_32 (output_bfd,
3367 8 + (chunk_entries * 4),
3368 spltlittbl->contents + (chunk * 8) + 4);
3369 }
3370
3371 /* All the dynamic relocations have been emitted at this point.
3372 Make sure the relocation sections are the correct size. */
eea6121a
AM		 3373 if (srelgot->size != (sizeof (Elf32_External_Rela)
3374 * srelgot->reloc_count)
3375 || srelplt->size != (sizeof (Elf32_External_Rela)
3376 * srelplt->reloc_count))
e0001a05
NC		 3377 abort ();
3378
3379 /* The .xt.lit.plt section has just been modified. This must
3380 happen before the code below which combines adjacent literal
3381 table entries, and the .xt.lit.plt contents have to be forced to
3382 the output here. */
3383 if (! bfd_set_section_contents (output_bfd,
3384 spltlittbl->output_section,
3385 spltlittbl->contents,
3386 spltlittbl->output_offset,
eea6121a 3387 spltlittbl->size))
e0001a05
NC		 3388 return FALSE;
3389 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3390 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3391 }
3392
3393 /* Combine adjacent literal table entries. */
1049f94e 3394 BFD_ASSERT (! info->relocatable);
e901de89 3395 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
f0e6fdb2 3396 sgotloc = htab->sgotloc;
d9ab3f29
BW		 3397 BFD_ASSERT (sgotloc);
3398 if (sxtlit)
3399 {
3400 num_xtlit_entries =
3401 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3402 if (num_xtlit_entries < 0)
3403 return FALSE;
3404 }
e0001a05
NC		 3405
3406 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 3407 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
e0001a05
NC		 3408 for (; dyncon < dynconend; dyncon++)
3409 {
3410 Elf_Internal_Dyn dyn;
e0001a05
NC		 3411
3412 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3413
3414 switch (dyn.d_tag)
3415 {
3416 default:
3417 break;
3418
3419 case DT_XTENSA_GOT_LOC_SZ:
e0001a05
NC		 3420 dyn.d_un.d_val = num_xtlit_entries;
3421 break;
3422
3423 case DT_XTENSA_GOT_LOC_OFF:
e29297b7 3424 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
f0e6fdb2
BW		 3425 break;
3426
e0001a05 3427 case DT_PLTGOT:
e29297b7 3428 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
f0e6fdb2
BW		 3429 break;
3430
e0001a05 3431 case DT_JMPREL:
e29297b7 3432 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
e0001a05
NC		 3433 break;
3434
3435 case DT_PLTRELSZ:
e29297b7 3436 dyn.d_un.d_val = htab->srelplt->output_section->size;
e0001a05
NC		 3437 break;
3438
3439 case DT_RELASZ:
3440 /* Adjust RELASZ to not include JMPREL. This matches what
3441 glibc expects and what is done for several other ELF
3442 targets (e.g., i386, alpha), but the "correct" behavior
3443 seems to be unresolved. Since the linker script arranges
3444 for .rela.plt to follow all other relocation sections, we
3445 don't have to worry about changing the DT_RELA entry. */
f0e6fdb2 3446 if (htab->srelplt)
e29297b7 3447 dyn.d_un.d_val -= htab->srelplt->output_section->size;
e0001a05
NC		 3448 break;
3449 }
3450
3451 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3452 }
3453
3454 return TRUE;
3455}
3456
3457\f
3458/* Functions for dealing with the e_flags field. */
3459
3460/* Merge backend specific data from an object file to the output
3461 object file when linking. */
3462
3463static bfd_boolean
7fa3d080 3464elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
e0001a05
NC		 3465{
3466 unsigned out_mach, in_mach;
3467 flagword out_flag, in_flag;
3468
cc643b88 3469 /* Check if we have the same endianness. */
e0001a05
NC		 3470 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3471 return FALSE;
3472
3473 /* Don't even pretend to support mixed-format linking. */
3474 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3475 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3476 return FALSE;
3477
3478 out_flag = elf_elfheader (obfd)->e_flags;
3479 in_flag = elf_elfheader (ibfd)->e_flags;
3480
3481 out_mach = out_flag & EF_XTENSA_MACH;
3482 in_mach = in_flag & EF_XTENSA_MACH;
43cd72b9 3483 if (out_mach != in_mach)
e0001a05
NC		 3484 {
3485 (*_bfd_error_handler)
43cd72b9 3486 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
d003868e 3487 ibfd, out_mach, in_mach);
e0001a05
NC		 3488 bfd_set_error (bfd_error_wrong_format);
3489 return FALSE;
3490 }
3491
3492 if (! elf_flags_init (obfd))
3493 {
3494 elf_flags_init (obfd) = TRUE;
3495 elf_elfheader (obfd)->e_flags = in_flag;
43cd72b9 3496
e0001a05
NC		 3497 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3498 && bfd_get_arch_info (obfd)->the_default)
3499 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3500 bfd_get_mach (ibfd));
43cd72b9 3501
e0001a05
NC		 3502 return TRUE;
3503 }
3504
43cd72b9
BW		 3505 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3506 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
e0001a05 3507
43cd72b9
BW		 3508 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3509 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
e0001a05
NC		 3510
3511 return TRUE;
3512}
3513
3514
3515static bfd_boolean
7fa3d080 3516elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
e0001a05
NC		 3517{
3518 BFD_ASSERT (!elf_flags_init (abfd)
3519 || elf_elfheader (abfd)->e_flags == flags);
3520
3521 elf_elfheader (abfd)->e_flags |= flags;
3522 elf_flags_init (abfd) = TRUE;
3523
3524 return TRUE;
3525}
3526
3527
e0001a05 3528static bfd_boolean
7fa3d080 3529elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
e0001a05
NC		 3530{
3531 FILE *f = (FILE *) farg;
3532 flagword e_flags = elf_elfheader (abfd)->e_flags;
3533
3534 fprintf (f, "\nXtensa header:\n");
43cd72b9 3535 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
e0001a05
NC		 3536 fprintf (f, "\nMachine = Base\n");
3537 else
3538 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3539
3540 fprintf (f, "Insn tables = %s\n",
3541 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3542
3543 fprintf (f, "Literal tables = %s\n",
3544 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3545
3546 return _bfd_elf_print_private_bfd_data (abfd, farg);
3547}
3548
3549
3550/* Set the right machine number for an Xtensa ELF file. */
3551
3552static bfd_boolean
7fa3d080 3553elf_xtensa_object_p (bfd *abfd)
e0001a05
NC		 3554{
3555 int mach;
3556 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3557
3558 switch (arch)
3559 {
3560 case E_XTENSA_MACH:
3561 mach = bfd_mach_xtensa;
3562 break;
3563 default:
3564 return FALSE;
3565 }
3566
3567 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3568 return TRUE;
3569}
3570
3571
3572/* The final processing done just before writing out an Xtensa ELF object
3573 file. This gets the Xtensa architecture right based on the machine
3574 number. */
3575
3576static void
7fa3d080
BW		 3577elf_xtensa_final_write_processing (bfd *abfd,
3578 bfd_boolean linker ATTRIBUTE_UNUSED)
e0001a05
NC		 3579{
3580 int mach;
3581 unsigned long val;
3582
3583 switch (mach = bfd_get_mach (abfd))
3584 {
3585 case bfd_mach_xtensa:
3586 val = E_XTENSA_MACH;
3587 break;
3588 default:
3589 return;
3590 }
3591
3592 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3593 elf_elfheader (abfd)->e_flags |= val;
3594}
3595
3596
3597static enum elf_reloc_type_class
7fa3d080 3598elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
e0001a05
NC		 3599{
3600 switch ((int) ELF32_R_TYPE (rela->r_info))
3601 {
3602 case R_XTENSA_RELATIVE:
3603 return reloc_class_relative;
3604 case R_XTENSA_JMP_SLOT:
3605 return reloc_class_plt;
3606 default:
3607 return reloc_class_normal;
3608 }
3609}
3610
3611\f
3612static bfd_boolean
7fa3d080
BW		 3613elf_xtensa_discard_info_for_section (bfd *abfd,
3614 struct elf_reloc_cookie *cookie,
3615 struct bfd_link_info *info,
3616 asection *sec)
e0001a05
NC		 3617{
3618 bfd_byte *contents;
e0001a05 3619 bfd_vma offset, actual_offset;
1d25768e
BW		 3620 bfd_size_type removed_bytes = 0;
3621 bfd_size_type entry_size;
e0001a05
NC		 3622
3623 if (sec->output_section
3624 && bfd_is_abs_section (sec->output_section))
3625 return FALSE;
3626
1d25768e
BW		 3627 if (xtensa_is_proptable_section (sec))
3628 entry_size = 12;
3629 else
3630 entry_size = 8;
3631
a3ef2d63 3632 if (sec->size == 0 || sec->size % entry_size != 0)
1d25768e
BW		 3633 return FALSE;
3634
e0001a05
NC		 3635 contents = retrieve_contents (abfd, sec, info->keep_memory);
3636 if (!contents)
3637 return FALSE;
3638
3639 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3640 if (!cookie->rels)
3641 {
3642 release_contents (sec, contents);
3643 return FALSE;
3644 }
3645
1d25768e
BW		 3646 /* Sort the relocations. They should already be in order when
3647 relaxation is enabled, but it might not be. */
3648 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3649 internal_reloc_compare);
3650
e0001a05
NC		 3651 cookie->rel = cookie->rels;
3652 cookie->relend = cookie->rels + sec->reloc_count;
3653
a3ef2d63 3654 for (offset = 0; offset < sec->size; offset += entry_size)
e0001a05
NC		 3655 {
3656 actual_offset = offset - removed_bytes;
3657
3658 /* The ...symbol_deleted_p function will skip over relocs but it
3659 won't adjust their offsets, so do that here. */
3660 while (cookie->rel < cookie->relend
3661 && cookie->rel->r_offset < offset)
3662 {
3663 cookie->rel->r_offset -= removed_bytes;
3664 cookie->rel++;
3665 }
3666
3667 while (cookie->rel < cookie->relend
3668 && cookie->rel->r_offset == offset)
3669 {
c152c796 3670 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
e0001a05
NC		 3671 {
3672 /* Remove the table entry. (If the reloc type is NONE, then
3673 the entry has already been merged with another and deleted
3674 during relaxation.) */
3675 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3676 {
3677 /* Shift the contents up. */
a3ef2d63 3678 if (offset + entry_size < sec->size)
e0001a05 3679 memmove (&contents[actual_offset],
1d25768e 3680 &contents[actual_offset + entry_size],
a3ef2d63 3681 sec->size - offset - entry_size);
1d25768e 3682 removed_bytes += entry_size;
e0001a05
NC		 3683 }
3684
3685 /* Remove this relocation. */
3686 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3687 }
3688
3689 /* Adjust the relocation offset for previous removals. This
3690 should not be done before calling ...symbol_deleted_p
3691 because it might mess up the offset comparisons there.
3692 Make sure the offset doesn't underflow in the case where
3693 the first entry is removed. */
3694 if (cookie->rel->r_offset >= removed_bytes)
3695 cookie->rel->r_offset -= removed_bytes;
3696 else
3697 cookie->rel->r_offset = 0;
3698
3699 cookie->rel++;
3700 }
3701 }
3702
3703 if (removed_bytes != 0)
3704 {
3705 /* Adjust any remaining relocs (shouldn't be any). */
3706 for (; cookie->rel < cookie->relend; cookie->rel++)
3707 {
3708 if (cookie->rel->r_offset >= removed_bytes)
3709 cookie->rel->r_offset -= removed_bytes;
3710 else
3711 cookie->rel->r_offset = 0;
3712 }
3713
3714 /* Clear the removed bytes. */
a3ef2d63 3715 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
e0001a05
NC		 3716
3717 pin_contents (sec, contents);
3718 pin_internal_relocs (sec, cookie->rels);
3719
eea6121a 3720 /* Shrink size. */
a3ef2d63
BW		 3721 if (sec->rawsize == 0)
3722 sec->rawsize = sec->size;
3723 sec->size -= removed_bytes;
b536dc1e
BW		 3724
3725 if (xtensa_is_littable_section (sec))
3726 {
f0e6fdb2
BW		 3727 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3728 if (sgotloc)
3729 sgotloc->size -= removed_bytes;
b536dc1e 3730 }
e0001a05
NC		 3731 }
3732 else
3733 {
3734 release_contents (sec, contents);
3735 release_internal_relocs (sec, cookie->rels);
3736 }
3737
3738 return (removed_bytes != 0);
3739}
3740
3741
3742static bfd_boolean
7fa3d080
BW		 3743elf_xtensa_discard_info (bfd *abfd,
3744 struct elf_reloc_cookie *cookie,
3745 struct bfd_link_info *info)
e0001a05
NC		 3746{
3747 asection *sec;
3748 bfd_boolean changed = FALSE;
3749
3750 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3751 {
3752 if (xtensa_is_property_section (sec))
3753 {
3754 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3755 changed = TRUE;
3756 }
3757 }
3758
3759 return changed;
3760}
3761
3762
3763static bfd_boolean
7fa3d080 3764elf_xtensa_ignore_discarded_relocs (asection *sec)
e0001a05
NC		 3765{
3766 return xtensa_is_property_section (sec);
3767}
3768
a77dc2cc
BW		 3769
3770static unsigned int
3771elf_xtensa_action_discarded (asection *sec)
3772{
3773 if (strcmp (".xt_except_table", sec->name) == 0)
3774 return 0;
3775
3776 if (strcmp (".xt_except_desc", sec->name) == 0)
3777 return 0;
3778
3779 return _bfd_elf_default_action_discarded (sec);
3780}
3781
e0001a05
NC		 3782\f
3783/* Support for core dump NOTE sections. */
3784
3785static bfd_boolean
7fa3d080 3786elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
e0001a05
NC		 3787{
3788 int offset;
eea6121a 3789 unsigned int size;
e0001a05
NC		 3790
3791 /* The size for Xtensa is variable, so don't try to recognize the format
3792 based on the size. Just assume this is GNU/Linux. */
3793
3794 /* pr_cursig */
3795 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3796
3797 /* pr_pid */
261b8d08 3798 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
e0001a05
NC		 3799
3800 /* pr_reg */
3801 offset = 72;
eea6121a 3802 size = note->descsz - offset - 4;
e0001a05
NC		 3803
3804 /* Make a ".reg/999" section. */
3805 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 3806 size, note->descpos + offset);
e0001a05
NC		 3807}
3808
3809
3810static bfd_boolean
7fa3d080 3811elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
e0001a05
NC		 3812{
3813 switch (note->descsz)
3814 {
3815 default:
3816 return FALSE;
3817
3818 case 128: /* GNU/Linux elf_prpsinfo */
3819 elf_tdata (abfd)->core_program
3820 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3821 elf_tdata (abfd)->core_command
3822 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3823 }
3824
3825 /* Note that for some reason, a spurious space is tacked
3826 onto the end of the args in some (at least one anyway)
3827 implementations, so strip it off if it exists. */
3828
3829 {
3830 char *command = elf_tdata (abfd)->core_command;
3831 int n = strlen (command);
3832
3833 if (0 < n && command[n - 1] == ' ')
3834 command[n - 1] = '\0';
3835 }
3836
3837 return TRUE;
3838}
3839
3840\f
3841/* Generic Xtensa configurability stuff. */
3842
3843static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3844static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3845static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3846static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3847static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3848static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3849static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3850static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3851
3852static void
7fa3d080 3853init_call_opcodes (void)
e0001a05
NC		 3854{
3855 if (callx0_op == XTENSA_UNDEFINED)
3856 {
3857 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3858 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3859 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3860 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3861 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3862 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3863 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3864 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3865 }
3866}
3867
3868
3869static bfd_boolean
7fa3d080 3870is_indirect_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3871{
3872 init_call_opcodes ();
3873 return (opcode == callx0_op
3874 || opcode == callx4_op
3875 || opcode == callx8_op
3876 || opcode == callx12_op);
3877}
3878
3879
3880static bfd_boolean
7fa3d080 3881is_direct_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3882{
3883 init_call_opcodes ();
3884 return (opcode == call0_op
3885 || opcode == call4_op
3886 || opcode == call8_op
3887 || opcode == call12_op);
3888}
3889
3890
3891static bfd_boolean
7fa3d080 3892is_windowed_call_opcode (xtensa_opcode opcode)
e0001a05
NC		 3893{
3894 init_call_opcodes ();
3895 return (opcode == call4_op
3896 || opcode == call8_op
3897 || opcode == call12_op
3898 || opcode == callx4_op
3899 || opcode == callx8_op
3900 || opcode == callx12_op);
3901}
3902
3903
28dbbc02
BW		 3904static bfd_boolean
3905get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3906{
3907 unsigned dst = (unsigned) -1;
3908
3909 init_call_opcodes ();
3910 if (opcode == callx0_op)
3911 dst = 0;
3912 else if (opcode == callx4_op)
3913 dst = 4;
3914 else if (opcode == callx8_op)
3915 dst = 8;
3916 else if (opcode == callx12_op)
3917 dst = 12;
3918
3919 if (dst == (unsigned) -1)
3920 return FALSE;
3921
3922 *pdst = dst;
3923 return TRUE;
3924}
3925
3926
43cd72b9
BW		 3927static xtensa_opcode
3928get_const16_opcode (void)
3929{
3930 static bfd_boolean done_lookup = FALSE;
3931 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3932 if (!done_lookup)
3933 {
3934 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3935 done_lookup = TRUE;
3936 }
3937 return const16_opcode;
3938}
3939
3940
e0001a05
NC		 3941static xtensa_opcode
3942get_l32r_opcode (void)
3943{
3944 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
43cd72b9
BW		 3945 static bfd_boolean done_lookup = FALSE;
3946
3947 if (!done_lookup)
e0001a05
NC		 3948 {
3949 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
43cd72b9 3950 done_lookup = TRUE;
e0001a05
NC		 3951 }
3952 return l32r_opcode;
3953}
3954
3955
3956static bfd_vma
7fa3d080 3957l32r_offset (bfd_vma addr, bfd_vma pc)
e0001a05
NC		 3958{
3959 bfd_vma offset;
3960
3961 offset = addr - ((pc+3) & -4);
3962 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3963 offset = (signed int) offset >> 2;
3964 BFD_ASSERT ((signed int) offset >> 16 == -1);
3965 return offset;
3966}
3967
3968
e0001a05 3969static int
7fa3d080 3970get_relocation_opnd (xtensa_opcode opcode, int r_type)
e0001a05 3971{
43cd72b9
BW		 3972 xtensa_isa isa = xtensa_default_isa;
3973 int last_immed, last_opnd, opi;
3974
3975 if (opcode == XTENSA_UNDEFINED)
3976 return XTENSA_UNDEFINED;
3977
3978 /* Find the last visible PC-relative immediate operand for the opcode.
3979 If there are no PC-relative immediates, then choose the last visible
3980 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3981 last_immed = XTENSA_UNDEFINED;
3982 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3983 for (opi = last_opnd - 1; opi >= 0; opi--)
3984 {
3985 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3986 continue;
3987 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3988 {
3989 last_immed = opi;
3990 break;
3991 }
3992 if (last_immed == XTENSA_UNDEFINED
3993 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3994 last_immed = opi;
3995 }
3996 if (last_immed < 0)
3997 return XTENSA_UNDEFINED;
3998
3999 /* If the operand number was specified in an old-style relocation,
4000 check for consistency with the operand computed above. */
4001 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4002 {
4003 int reloc_opnd = r_type - R_XTENSA_OP0;
4004 if (reloc_opnd != last_immed)
4005 return XTENSA_UNDEFINED;
4006 }
4007
4008 return last_immed;
4009}
4010
4011
4012int
7fa3d080 4013get_relocation_slot (int r_type)
43cd72b9
BW		 4014{
4015 switch (r_type)
4016 {
4017 case R_XTENSA_OP0:
4018 case R_XTENSA_OP1:
4019 case R_XTENSA_OP2:
4020 return 0;
4021
4022 default:
4023 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4024 return r_type - R_XTENSA_SLOT0_OP;
4025 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4026 return r_type - R_XTENSA_SLOT0_ALT;
4027 break;
4028 }
4029
4030 return XTENSA_UNDEFINED;
e0001a05
NC		 4031}
4032
4033
4034/* Get the opcode for a relocation. */
4035
4036static xtensa_opcode
7fa3d080
BW		 4037get_relocation_opcode (bfd *abfd,
4038 asection *sec,
4039 bfd_byte *contents,
4040 Elf_Internal_Rela *irel)
e0001a05
NC		 4041{
4042 static xtensa_insnbuf ibuff = NULL;
43cd72b9 4043 static xtensa_insnbuf sbuff = NULL;
e0001a05 4044 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 4045 xtensa_format fmt;
4046 int slot;
e0001a05
NC		 4047
4048 if (contents == NULL)
4049 return XTENSA_UNDEFINED;
4050
43cd72b9 4051 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
e0001a05
NC		 4052 return XTENSA_UNDEFINED;
4053
4054 if (ibuff == NULL)
43cd72b9
BW		 4055 {
4056 ibuff = xtensa_insnbuf_alloc (isa);
4057 sbuff = xtensa_insnbuf_alloc (isa);
4058 }
4059
e0001a05 4060 /* Decode the instruction. */
43cd72b9
BW		 4061 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4062 sec->size - irel->r_offset);
4063 fmt = xtensa_format_decode (isa, ibuff);
4064 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4065 if (slot == XTENSA_UNDEFINED)
4066 return XTENSA_UNDEFINED;
4067 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4068 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
e0001a05
NC		 4069}
4070
4071
4072bfd_boolean
7fa3d080
BW		 4073is_l32r_relocation (bfd *abfd,
4074 asection *sec,
4075 bfd_byte *contents,
4076 Elf_Internal_Rela *irel)
e0001a05
NC		 4077{
4078 xtensa_opcode opcode;
43cd72b9 4079 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
e0001a05 4080 return FALSE;
43cd72b9 4081 opcode = get_relocation_opcode (abfd, sec, contents, irel);
e0001a05
NC		 4082 return (opcode == get_l32r_opcode ());
4083}
4084
e0001a05 4085
43cd72b9 4086static bfd_size_type
7fa3d080
BW		 4087get_asm_simplify_size (bfd_byte *contents,
4088 bfd_size_type content_len,
4089 bfd_size_type offset)
e0001a05 4090{
43cd72b9 4091 bfd_size_type insnlen, size = 0;
e0001a05 4092
43cd72b9
BW		 4093 /* Decode the size of the next two instructions. */
4094 insnlen = insn_decode_len (contents, content_len, offset);
4095 if (insnlen == 0)
4096 return 0;
e0001a05 4097
43cd72b9 4098 size += insnlen;
e0001a05 4099
43cd72b9
BW		 4100 insnlen = insn_decode_len (contents, content_len, offset + size);
4101 if (insnlen == 0)
4102 return 0;
e0001a05 4103
43cd72b9
BW		 4104 size += insnlen;
4105 return size;
4106}
e0001a05 4107
43cd72b9
BW		 4108
4109bfd_boolean
7fa3d080 4110is_alt_relocation (int r_type)
43cd72b9
BW		 4111{
4112 return (r_type >= R_XTENSA_SLOT0_ALT
4113 && r_type <= R_XTENSA_SLOT14_ALT);
e0001a05
NC		 4114}
4115
4116
43cd72b9 4117bfd_boolean
7fa3d080 4118is_operand_relocation (int r_type)
e0001a05 4119{
43cd72b9
BW		 4120 switch (r_type)
4121 {
4122 case R_XTENSA_OP0:
4123 case R_XTENSA_OP1:
4124 case R_XTENSA_OP2:
4125 return TRUE;
e0001a05 4126
43cd72b9
BW		 4127 default:
4128 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4129 return TRUE;
4130 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4131 return TRUE;
4132 break;
4133 }
e0001a05 4134
43cd72b9 4135 return FALSE;
e0001a05
NC		 4136}
4137
43cd72b9
BW		 4138
4139#define MIN_INSN_LENGTH 2
e0001a05 4140
43cd72b9
BW		 4141/* Return 0 if it fails to decode. */
4142
4143bfd_size_type
7fa3d080
BW		 4144insn_decode_len (bfd_byte *contents,
4145 bfd_size_type content_len,
4146 bfd_size_type offset)
e0001a05 4147{
43cd72b9
BW		 4148 int insn_len;
4149 xtensa_isa isa = xtensa_default_isa;
4150 xtensa_format fmt;
4151 static xtensa_insnbuf ibuff = NULL;
e0001a05 4152
43cd72b9
BW		 4153 if (offset + MIN_INSN_LENGTH > content_len)
4154 return 0;
e0001a05 4155
43cd72b9
BW		 4156 if (ibuff == NULL)
4157 ibuff = xtensa_insnbuf_alloc (isa);
4158 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4159 content_len - offset);
4160 fmt = xtensa_format_decode (isa, ibuff);
4161 if (fmt == XTENSA_UNDEFINED)
4162 return 0;
4163 insn_len = xtensa_format_length (isa, fmt);
4164 if (insn_len == XTENSA_UNDEFINED)
4165 return 0;
4166 return insn_len;
e0001a05
NC		 4167}
4168
4169
43cd72b9
BW		 4170/* Decode the opcode for a single slot instruction.
4171 Return 0 if it fails to decode or the instruction is multi-slot. */
e0001a05 4172
43cd72b9 4173xtensa_opcode
7fa3d080
BW		 4174insn_decode_opcode (bfd_byte *contents,
4175 bfd_size_type content_len,
4176 bfd_size_type offset,
4177 int slot)
e0001a05 4178{
e0001a05 4179 xtensa_isa isa = xtensa_default_isa;
43cd72b9
BW		 4180 xtensa_format fmt;
4181 static xtensa_insnbuf insnbuf = NULL;
4182 static xtensa_insnbuf slotbuf = NULL;
4183
4184 if (offset + MIN_INSN_LENGTH > content_len)
e0001a05
NC		 4185 return XTENSA_UNDEFINED;
4186
4187 if (insnbuf == NULL)
43cd72b9
BW		 4188 {
4189 insnbuf = xtensa_insnbuf_alloc (isa);
4190 slotbuf = xtensa_insnbuf_alloc (isa);
4191 }
4192
4193 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4194 content_len - offset);
4195 fmt = xtensa_format_decode (isa, insnbuf);
4196 if (fmt == XTENSA_UNDEFINED)
e0001a05 4197 return XTENSA_UNDEFINED;
43cd72b9
BW		 4198
4199 if (slot >= xtensa_format_num_slots (isa, fmt))
e0001a05 4200 return XTENSA_UNDEFINED;
e0001a05 4201
43cd72b9
BW		 4202 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4203 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4204}
e0001a05 4205
e0001a05 4206
43cd72b9
BW		 4207/* The offset is the offset in the contents.
4208 The address is the address of that offset. */
e0001a05 4209
43cd72b9 4210static bfd_boolean
7fa3d080
BW		 4211check_branch_target_aligned (bfd_byte *contents,
4212 bfd_size_type content_length,
4213 bfd_vma offset,
4214 bfd_vma address)
43cd72b9
BW		 4215{
4216 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4217 if (insn_len == 0)
4218 return FALSE;
4219 return check_branch_target_aligned_address (address, insn_len);
4220}
e0001a05 4221
e0001a05 4222
43cd72b9 4223static bfd_boolean
7fa3d080
BW		 4224check_loop_aligned (bfd_byte *contents,
4225 bfd_size_type content_length,
4226 bfd_vma offset,
4227 bfd_vma address)
e0001a05 4228{
43cd72b9 4229 bfd_size_type loop_len, insn_len;
64b607e6 4230 xtensa_opcode opcode;
e0001a05 4231
64b607e6
BW		 4232 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4233 if (opcode == XTENSA_UNDEFINED
4234 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4235 {
4236 BFD_ASSERT (FALSE);
4237 return FALSE;
4238 }
4239
43cd72b9 4240 loop_len = insn_decode_len (contents, content_length, offset);
43cd72b9 4241 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
64b607e6
BW		 4242 if (loop_len == 0 || insn_len == 0)
4243 {
4244 BFD_ASSERT (FALSE);
4245 return FALSE;
4246 }
e0001a05 4247
43cd72b9
BW		 4248 return check_branch_target_aligned_address (address + loop_len, insn_len);
4249}
e0001a05 4250
e0001a05
NC		 4251
4252static bfd_boolean
7fa3d080 4253check_branch_target_aligned_address (bfd_vma addr, int len)
e0001a05 4254{
43cd72b9
BW		 4255 if (len == 8)
4256 return (addr % 8 == 0);
4257 return ((addr >> 2) == ((addr + len - 1) >> 2));
e0001a05
NC		 4258}
4259
43cd72b9
BW		 4260\f
4261/* Instruction widening and narrowing. */
e0001a05 4262
7fa3d080
BW		 4263/* When FLIX is available we need to access certain instructions only
4264 when they are 16-bit or 24-bit instructions. This table caches
4265 information about such instructions by walking through all the
4266 opcodes and finding the smallest single-slot format into which each
4267 can be encoded. */
4268
4269static xtensa_format *op_single_fmt_table = NULL;
e0001a05
NC		 4270
4271
7fa3d080
BW		 4272static void
4273init_op_single_format_table (void)
e0001a05 4274{
7fa3d080
BW		 4275 xtensa_isa isa = xtensa_default_isa;
4276 xtensa_insnbuf ibuf;
4277 xtensa_opcode opcode;
4278 xtensa_format fmt;
4279 int num_opcodes;
4280
4281 if (op_single_fmt_table)
4282 return;
4283
4284 ibuf = xtensa_insnbuf_alloc (isa);
4285 num_opcodes = xtensa_isa_num_opcodes (isa);
4286
4287 op_single_fmt_table = (xtensa_format *)
4288 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4289 for (opcode = 0; opcode < num_opcodes; opcode++)
4290 {
4291 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4292 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4293 {
4294 if (xtensa_format_num_slots (isa, fmt) == 1
4295 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4296 {
4297 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4298 int fmt_length = xtensa_format_length (isa, fmt);
4299 if (old_fmt == XTENSA_UNDEFINED
4300 || fmt_length < xtensa_format_length (isa, old_fmt))
4301 op_single_fmt_table[opcode] = fmt;
4302 }
4303 }
4304 }
4305 xtensa_insnbuf_free (isa, ibuf);
4306}
4307
4308
4309static xtensa_format
4310get_single_format (xtensa_opcode opcode)
4311{
4312 init_op_single_format_table ();
4313 return op_single_fmt_table[opcode];
4314}
e0001a05 4315
e0001a05 4316
43cd72b9
BW		 4317/* For the set of narrowable instructions we do NOT include the
4318 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4319 involved during linker relaxation that may require these to
4320 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4321 requires special case code to ensure it only works when op1 == op2. */
e0001a05 4322
7fa3d080
BW		 4323struct string_pair
4324{
4325 const char *wide;
4326 const char *narrow;
4327};
4328
43cd72b9 4329struct string_pair narrowable[] =
e0001a05 4330{
43cd72b9
BW		 4331 { "add", "add.n" },
4332 { "addi", "addi.n" },
4333 { "addmi", "addi.n" },
4334 { "l32i", "l32i.n" },
4335 { "movi", "movi.n" },
4336 { "ret", "ret.n" },
4337 { "retw", "retw.n" },
4338 { "s32i", "s32i.n" },
4339 { "or", "mov.n" } /* special case only when op1 == op2 */
4340};
e0001a05 4341
43cd72b9 4342struct string_pair widenable[] =
e0001a05 4343{
43cd72b9
BW		 4344 { "add", "add.n" },
4345 { "addi", "addi.n" },
4346 { "addmi", "addi.n" },
4347 { "beqz", "beqz.n" },
4348 { "bnez", "bnez.n" },
4349 { "l32i", "l32i.n" },
4350 { "movi", "movi.n" },
4351 { "ret", "ret.n" },
4352 { "retw", "retw.n" },
4353 { "s32i", "s32i.n" },
4354 { "or", "mov.n" } /* special case only when op1 == op2 */
4355};
e0001a05
NC		 4356
4357
64b607e6
BW		 4358/* Check if an instruction can be "narrowed", i.e., changed from a standard
4359 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4360 return the instruction buffer holding the narrow instruction. Otherwise,
4361 return 0. The set of valid narrowing are specified by a string table
43cd72b9
BW		 4362 but require some special case operand checks in some cases. */
4363
64b607e6
BW		 4364static xtensa_insnbuf
4365can_narrow_instruction (xtensa_insnbuf slotbuf,
4366 xtensa_format fmt,
4367 xtensa_opcode opcode)
e0001a05 4368{
43cd72b9 4369 xtensa_isa isa = xtensa_default_isa;
64b607e6
BW		 4370 xtensa_format o_fmt;
4371 unsigned opi;
e0001a05 4372
43cd72b9
BW		 4373 static xtensa_insnbuf o_insnbuf = NULL;
4374 static xtensa_insnbuf o_slotbuf = NULL;
e0001a05 4375
64b607e6 4376 if (o_insnbuf == NULL)
43cd72b9 4377 {
43cd72b9
BW		 4378 o_insnbuf = xtensa_insnbuf_alloc (isa);
4379 o_slotbuf = xtensa_insnbuf_alloc (isa);
4380 }
e0001a05 4381
64b607e6 4382 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
43cd72b9
BW		 4383 {
4384 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
e0001a05 4385
43cd72b9
BW		 4386 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4387 {
4388 uint32 value, newval;
4389 int i, operand_count, o_operand_count;
4390 xtensa_opcode o_opcode;
e0001a05 4391
43cd72b9
BW		 4392 /* Address does not matter in this case. We might need to
4393 fix it to handle branches/jumps. */
4394 bfd_vma self_address = 0;
e0001a05 4395
43cd72b9
BW		 4396 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4397 if (o_opcode == XTENSA_UNDEFINED)
64b607e6 4398 return 0;
43cd72b9
BW		 4399 o_fmt = get_single_format (o_opcode);
4400 if (o_fmt == XTENSA_UNDEFINED)
64b607e6 4401 return 0;
e0001a05 4402
43cd72b9
BW		 4403 if (xtensa_format_length (isa, fmt) != 3
4404 || xtensa_format_length (isa, o_fmt) != 2)
64b607e6 4405 return 0;
e0001a05 4406
43cd72b9
BW		 4407 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4408 operand_count = xtensa_opcode_num_operands (isa, opcode);
4409 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
e0001a05 4410
43cd72b9 4411 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
64b607e6 4412 return 0;
e0001a05 4413
43cd72b9
BW		 4414 if (!is_or)
4415 {
4416 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
64b607e6 4417 return 0;
43cd72b9
BW		 4418 }
4419 else
4420 {
4421 uint32 rawval0, rawval1, rawval2;
e0001a05 4422
64b607e6
BW		 4423 if (o_operand_count + 1 != operand_count
4424 || xtensa_operand_get_field (isa, opcode, 0,
4425 fmt, 0, slotbuf, &rawval0) != 0
4426 || xtensa_operand_get_field (isa, opcode, 1,
4427 fmt, 0, slotbuf, &rawval1) != 0
4428 || xtensa_operand_get_field (isa, opcode, 2,
4429 fmt, 0, slotbuf, &rawval2) != 0
4430 || rawval1 != rawval2
4431 || rawval0 == rawval1 /* it is a nop */)
4432 return 0;
43cd72b9 4433 }
e0001a05 4434
43cd72b9
BW		 4435 for (i = 0; i < o_operand_count; ++i)
4436 {
4437 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4438 slotbuf, &value)
4439 || xtensa_operand_decode (isa, opcode, i, &value))
64b607e6 4440 return 0;
e0001a05 4441
43cd72b9
BW		 4442 /* PC-relative branches need adjustment, but
4443 the PC-rel operand will always have a relocation. */
4444 newval = value;
4445 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4446 self_address)
4447 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4448 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4449 o_slotbuf, newval))
64b607e6 4450 return 0;
43cd72b9 4451 }
e0001a05 4452
64b607e6
BW		 4453 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4454 return 0;
e0001a05 4455
64b607e6 4456 return o_insnbuf;
43cd72b9
BW		 4457 }
4458 }
64b607e6 4459 return 0;
43cd72b9 4460}
e0001a05 4461
e0001a05 4462
64b607e6
BW		 4463/* Attempt to narrow an instruction. If the narrowing is valid, perform
4464 the action in-place directly into the contents and return TRUE. Otherwise,
4465 the return value is FALSE and the contents are not modified. */
e0001a05 4466
43cd72b9 4467static bfd_boolean
64b607e6
BW		 4468narrow_instruction (bfd_byte *contents,
4469 bfd_size_type content_length,
4470 bfd_size_type offset)
e0001a05 4471{
43cd72b9 4472 xtensa_opcode opcode;
64b607e6 4473 bfd_size_type insn_len;
43cd72b9 4474 xtensa_isa isa = xtensa_default_isa;
64b607e6
BW		 4475 xtensa_format fmt;
4476 xtensa_insnbuf o_insnbuf;
e0001a05 4477
43cd72b9
BW		 4478 static xtensa_insnbuf insnbuf = NULL;
4479 static xtensa_insnbuf slotbuf = NULL;
e0001a05 4480
43cd72b9
BW		 4481 if (insnbuf == NULL)
4482 {
4483 insnbuf = xtensa_insnbuf_alloc (isa);
4484 slotbuf = xtensa_insnbuf_alloc (isa);
43cd72b9 4485 }
e0001a05 4486
43cd72b9 4487 BFD_ASSERT (offset < content_length);
2c8c90bc 4488
43cd72b9 4489 if (content_length < 2)
e0001a05
NC		 4490 return FALSE;
4491
64b607e6 4492 /* We will hand-code a few of these for a little while.
43cd72b9
BW		 4493 These have all been specified in the assembler aleady. */
4494 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4495 content_length - offset);
4496 fmt = xtensa_format_decode (isa, insnbuf);
4497 if (xtensa_format_num_slots (isa, fmt) != 1)
e0001a05
NC		 4498 return FALSE;
4499
43cd72b9 4500 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
e0001a05
NC		 4501 return FALSE;
4502
43cd72b9
BW		 4503 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4504 if (opcode == XTENSA_UNDEFINED)
e0001a05 4505 return FALSE;
43cd72b9
BW		 4506 insn_len = xtensa_format_length (isa, fmt);
4507 if (insn_len > content_length)
4508 return FALSE;
4509
64b607e6
BW		 4510 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4511 if (o_insnbuf)
4512 {
4513 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4514 content_length - offset);
4515 return TRUE;
4516 }
4517
4518 return FALSE;
4519}
4520
4521
4522/* Check if an instruction can be "widened", i.e., changed from a 2-byte
4523 "density" instruction to a standard 3-byte instruction. If it is valid,
4524 return the instruction buffer holding the wide instruction. Otherwise,
4525 return 0. The set of valid widenings are specified by a string table
4526 but require some special case operand checks in some cases. */
4527
4528static xtensa_insnbuf
4529can_widen_instruction (xtensa_insnbuf slotbuf,
4530 xtensa_format fmt,
4531 xtensa_opcode opcode)
4532{
4533 xtensa_isa isa = xtensa_default_isa;
4534 xtensa_format o_fmt;
4535 unsigned opi;
4536
4537 static xtensa_insnbuf o_insnbuf = NULL;
4538 static xtensa_insnbuf o_slotbuf = NULL;
4539
4540 if (o_insnbuf == NULL)
4541 {
4542 o_insnbuf = xtensa_insnbuf_alloc (isa);
4543 o_slotbuf = xtensa_insnbuf_alloc (isa);
4544 }
4545
4546 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
e0001a05 4547 {
43cd72b9
BW		 4548 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4549 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4550 || strcmp ("bnez", widenable[opi].wide) == 0);
e0001a05 4551
43cd72b9
BW		 4552 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4553 {
4554 uint32 value, newval;
4555 int i, operand_count, o_operand_count, check_operand_count;
4556 xtensa_opcode o_opcode;
e0001a05 4557
43cd72b9
BW		 4558 /* Address does not matter in this case. We might need to fix it
4559 to handle branches/jumps. */
4560 bfd_vma self_address = 0;
e0001a05 4561
43cd72b9
BW		 4562 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4563 if (o_opcode == XTENSA_UNDEFINED)
64b607e6 4564 return 0;
43cd72b9
BW		 4565 o_fmt = get_single_format (o_opcode);
4566 if (o_fmt == XTENSA_UNDEFINED)
64b607e6 4567 return 0;
e0001a05 4568
43cd72b9
BW		 4569 if (xtensa_format_length (isa, fmt) != 2
4570 || xtensa_format_length (isa, o_fmt) != 3)
64b607e6 4571 return 0;
e0001a05 4572
43cd72b9
BW		 4573 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4574 operand_count = xtensa_opcode_num_operands (isa, opcode);
4575 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4576 check_operand_count = o_operand_count;
e0001a05 4577
43cd72b9 4578 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
64b607e6 4579 return 0;
e0001a05 4580
43cd72b9
BW		 4581 if (!is_or)
4582 {
4583 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
64b607e6 4584 return 0;
43cd72b9
BW		 4585 }
4586 else
4587 {
4588 uint32 rawval0, rawval1;
4589
64b607e6
BW		 4590 if (o_operand_count != operand_count + 1
4591 || xtensa_operand_get_field (isa, opcode, 0,
4592 fmt, 0, slotbuf, &rawval0) != 0
4593 || xtensa_operand_get_field (isa, opcode, 1,
4594 fmt, 0, slotbuf, &rawval1) != 0
4595 || rawval0 == rawval1 /* it is a nop */)
4596 return 0;
43cd72b9
BW		 4597 }
4598 if (is_branch)
4599 check_operand_count--;
4600
64b607e6 4601 for (i = 0; i < check_operand_count; i++)
43cd72b9
BW		 4602 {
4603 int new_i = i;
4604 if (is_or && i == o_operand_count - 1)
4605 new_i = i - 1;
4606 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4607 slotbuf, &value)
4608 || xtensa_operand_decode (isa, opcode, new_i, &value))
64b607e6 4609 return 0;
43cd72b9
BW		 4610
4611 /* PC-relative branches need adjustment, but
4612 the PC-rel operand will always have a relocation. */
4613 newval = value;
4614 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4615 self_address)
4616 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4617 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4618 o_slotbuf, newval))
64b607e6 4619 return 0;
43cd72b9
BW		 4620 }
4621
4622 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
64b607e6 4623 return 0;
43cd72b9 4624
64b607e6 4625 return o_insnbuf;
43cd72b9
BW		 4626 }
4627 }
64b607e6
BW		 4628 return 0;
4629}
4630
4631
4632/* Attempt to widen an instruction. If the widening is valid, perform
4633 the action in-place directly into the contents and return TRUE. Otherwise,
4634 the return value is FALSE and the contents are not modified. */
4635
4636static bfd_boolean
4637widen_instruction (bfd_byte *contents,
4638 bfd_size_type content_length,
4639 bfd_size_type offset)
4640{
4641 xtensa_opcode opcode;
4642 bfd_size_type insn_len;
4643 xtensa_isa isa = xtensa_default_isa;
4644 xtensa_format fmt;
4645 xtensa_insnbuf o_insnbuf;
4646
4647 static xtensa_insnbuf insnbuf = NULL;
4648 static xtensa_insnbuf slotbuf = NULL;
4649
4650 if (insnbuf == NULL)
4651 {
4652 insnbuf = xtensa_insnbuf_alloc (isa);
4653 slotbuf = xtensa_insnbuf_alloc (isa);
4654 }
4655
4656 BFD_ASSERT (offset < content_length);
4657
4658 if (content_length < 2)
4659 return FALSE;
4660
4661 /* We will hand-code a few of these for a little while.
4662 These have all been specified in the assembler aleady. */
4663 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4664 content_length - offset);
4665 fmt = xtensa_format_decode (isa, insnbuf);
4666 if (xtensa_format_num_slots (isa, fmt) != 1)
4667 return FALSE;
4668
4669 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4670 return FALSE;
4671
4672 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4673 if (opcode == XTENSA_UNDEFINED)
4674 return FALSE;
4675 insn_len = xtensa_format_length (isa, fmt);
4676 if (insn_len > content_length)
4677 return FALSE;
4678
4679 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4680 if (o_insnbuf)
4681 {
4682 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4683 content_length - offset);
4684 return TRUE;
4685 }
43cd72b9 4686 return FALSE;
e0001a05
NC		 4687}
4688
43cd72b9
BW		 4689\f
4690/* Code for transforming CALLs at link-time. */
e0001a05 4691
43cd72b9 4692static bfd_reloc_status_type
7fa3d080
BW		 4693elf_xtensa_do_asm_simplify (bfd_byte *contents,
4694 bfd_vma address,
4695 bfd_vma content_length,
4696 char **error_message)
e0001a05 4697{
43cd72b9
BW		 4698 static xtensa_insnbuf insnbuf = NULL;
4699 static xtensa_insnbuf slotbuf = NULL;
4700 xtensa_format core_format = XTENSA_UNDEFINED;
4701 xtensa_opcode opcode;
4702 xtensa_opcode direct_call_opcode;
4703 xtensa_isa isa = xtensa_default_isa;
4704 bfd_byte *chbuf = contents + address;
4705 int opn;
e0001a05 4706
43cd72b9 4707 if (insnbuf == NULL)
e0001a05 4708 {
43cd72b9
BW		 4709 insnbuf = xtensa_insnbuf_alloc (isa);
4710 slotbuf = xtensa_insnbuf_alloc (isa);
e0001a05 4711 }
e0001a05 4712
43cd72b9
BW		 4713 if (content_length < address)
4714 {
4715 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4716 return bfd_reloc_other;
4717 }
e0001a05 4718
43cd72b9
BW		 4719 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4720 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4721 if (direct_call_opcode == XTENSA_UNDEFINED)
4722 {
4723 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4724 return bfd_reloc_other;
4725 }
4726
4727 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4728 core_format = xtensa_format_lookup (isa, "x24");
4729 opcode = xtensa_opcode_lookup (isa, "or");
4730 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4731 for (opn = 0; opn < 3; opn++)
4732 {
4733 uint32 regno = 1;
4734 xtensa_operand_encode (isa, opcode, opn, &regno);
4735 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4736 slotbuf, regno);
4737 }
4738 xtensa_format_encode (isa, core_format, insnbuf);
4739 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4740 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
e0001a05 4741
43cd72b9
BW		 4742 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4743 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4744 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
e0001a05 4745
43cd72b9
BW		 4746 xtensa_format_encode (isa, core_format, insnbuf);
4747 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4748 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4749 content_length - address - 3);
e0001a05 4750
43cd72b9
BW		 4751 return bfd_reloc_ok;
4752}
e0001a05 4753
e0001a05 4754
43cd72b9 4755static bfd_reloc_status_type
7fa3d080
BW		 4756contract_asm_expansion (bfd_byte *contents,
4757 bfd_vma content_length,
4758 Elf_Internal_Rela *irel,
4759 char **error_message)
43cd72b9
BW		 4760{
4761 bfd_reloc_status_type retval =
4762 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4763 error_message);
e0001a05 4764
43cd72b9
BW		 4765 if (retval != bfd_reloc_ok)
4766 return bfd_reloc_dangerous;
e0001a05 4767
43cd72b9
BW		 4768 /* Update the irel->r_offset field so that the right immediate and
4769 the right instruction are modified during the relocation. */
4770 irel->r_offset += 3;
4771 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4772 return bfd_reloc_ok;
4773}
e0001a05 4774
e0001a05 4775
43cd72b9 4776static xtensa_opcode
7fa3d080 4777swap_callx_for_call_opcode (xtensa_opcode opcode)
e0001a05 4778{
43cd72b9 4779 init_call_opcodes ();
e0001a05 4780
43cd72b9
BW		 4781 if (opcode == callx0_op) return call0_op;
4782 if (opcode == callx4_op) return call4_op;
4783 if (opcode == callx8_op) return call8_op;
4784 if (opcode == callx12_op) return call12_op;
e0001a05 4785
43cd72b9
BW		 4786 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4787 return XTENSA_UNDEFINED;
4788}
e0001a05 4789
e0001a05 4790
43cd72b9
BW		 4791/* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4792 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4793 If not, return XTENSA_UNDEFINED. */
e0001a05 4794
43cd72b9
BW		 4795#define L32R_TARGET_REG_OPERAND 0
4796#define CONST16_TARGET_REG_OPERAND 0
4797#define CALLN_SOURCE_OPERAND 0
e0001a05 4798
43cd72b9 4799static xtensa_opcode
7fa3d080 4800get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
e0001a05 4801{
43cd72b9
BW		 4802 static xtensa_insnbuf insnbuf = NULL;
4803 static xtensa_insnbuf slotbuf = NULL;
4804 xtensa_format fmt;
4805 xtensa_opcode opcode;
4806 xtensa_isa isa = xtensa_default_isa;
4807 uint32 regno, const16_regno, call_regno;
4808 int offset = 0;
e0001a05 4809
43cd72b9 4810 if (insnbuf == NULL)
e0001a05 4811 {
43cd72b9
BW		 4812 insnbuf = xtensa_insnbuf_alloc (isa);
4813 slotbuf = xtensa_insnbuf_alloc (isa);
e0001a05 4814 }
43cd72b9
BW		 4815
4816 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4817 fmt = xtensa_format_decode (isa, insnbuf);
4818 if (fmt == XTENSA_UNDEFINED
4819 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4820 return XTENSA_UNDEFINED;
4821
4822 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4823 if (opcode == XTENSA_UNDEFINED)
4824 return XTENSA_UNDEFINED;
4825
4826 if (opcode == get_l32r_opcode ())
e0001a05 4827 {
43cd72b9
BW		 4828 if (p_uses_l32r)
4829 *p_uses_l32r = TRUE;
4830 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4831 fmt, 0, slotbuf, &regno)
4832 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4833 &regno))
4834 return XTENSA_UNDEFINED;
e0001a05 4835 }
43cd72b9 4836 else if (opcode == get_const16_opcode ())
e0001a05 4837 {
43cd72b9
BW		 4838 if (p_uses_l32r)
4839 *p_uses_l32r = FALSE;
4840 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4841 fmt, 0, slotbuf, &regno)
4842 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4843 &regno))
4844 return XTENSA_UNDEFINED;
4845
4846 /* Check that the next instruction is also CONST16. */
4847 offset += xtensa_format_length (isa, fmt);
4848 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4849 fmt = xtensa_format_decode (isa, insnbuf);
4850 if (fmt == XTENSA_UNDEFINED
4851 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4852 return XTENSA_UNDEFINED;
4853 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4854 if (opcode != get_const16_opcode ())
4855 return XTENSA_UNDEFINED;
4856
4857 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4858 fmt, 0, slotbuf, &const16_regno)
4859 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4860 &const16_regno)
4861 || const16_regno != regno)
4862 return XTENSA_UNDEFINED;
e0001a05 4863 }
43cd72b9
BW		 4864 else
4865 return XTENSA_UNDEFINED;
e0001a05 4866
43cd72b9
BW		 4867 /* Next instruction should be an CALLXn with operand 0 == regno. */
4868 offset += xtensa_format_length (isa, fmt);
4869 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4870 fmt = xtensa_format_decode (isa, insnbuf);
4871 if (fmt == XTENSA_UNDEFINED
4872 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4873 return XTENSA_UNDEFINED;
4874 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4875 if (opcode == XTENSA_UNDEFINED
4876 || !is_indirect_call_opcode (opcode))
4877 return XTENSA_UNDEFINED;
e0001a05 4878
43cd72b9
BW		 4879 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4880 fmt, 0, slotbuf, &call_regno)
4881 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4882 &call_regno))
4883 return XTENSA_UNDEFINED;
e0001a05 4884
43cd72b9
BW		 4885 if (call_regno != regno)
4886 return XTENSA_UNDEFINED;
e0001a05 4887
43cd72b9
BW		 4888 return opcode;
4889}
e0001a05 4890
43cd72b9
BW		 4891\f
4892/* Data structures used during relaxation. */
e0001a05 4893
43cd72b9 4894/* r_reloc: relocation values. */
e0001a05 4895
43cd72b9
BW		 4896/* Through the relaxation process, we need to keep track of the values
4897 that will result from evaluating relocations. The standard ELF
4898 relocation structure is not sufficient for this purpose because we're
4899 operating on multiple input files at once, so we need to know which
4900 input file a relocation refers to. The r_reloc structure thus
4901 records both the input file (bfd) and ELF relocation.
e0001a05 4902
43cd72b9
BW		 4903 For efficiency, an r_reloc also contains a "target_offset" field to
4904 cache the target-section-relative offset value that is represented by
4905 the relocation.
4906
4907 The r_reloc also contains a virtual offset that allows multiple
4908 inserted literals to be placed at the same "address" with
4909 different offsets. */
e0001a05 4910
43cd72b9 4911typedef struct r_reloc_struct r_reloc;
e0001a05 4912
43cd72b9 4913struct r_reloc_struct
e0001a05 4914{
43cd72b9
BW		 4915 bfd *abfd;
4916 Elf_Internal_Rela rela;
e0001a05 4917 bfd_vma target_offset;
43cd72b9 4918 bfd_vma virtual_offset;
e0001a05
NC		 4919};
4920
e0001a05 4921
43cd72b9
BW		 4922/* The r_reloc structure is included by value in literal_value, but not
4923 every literal_value has an associated relocation -- some are simple
4924 constants. In such cases, we set all the fields in the r_reloc
4925 struct to zero. The r_reloc_is_const function should be used to
4926 detect this case. */
e0001a05 4927
43cd72b9 4928static bfd_boolean
7fa3d080 4929r_reloc_is_const (const r_reloc *r_rel)
e0001a05 4930{
43cd72b9 4931 return (r_rel->abfd == NULL);
e0001a05
NC		 4932}
4933
4934
43cd72b9 4935static bfd_vma
7fa3d080 4936r_reloc_get_target_offset (const r_reloc *r_rel)
e0001a05 4937{
43cd72b9
BW		 4938 bfd_vma target_offset;
4939 unsigned long r_symndx;
e0001a05 4940
43cd72b9
BW		 4941 BFD_ASSERT (!r_reloc_is_const (r_rel));
4942 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4943 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4944 return (target_offset + r_rel->rela.r_addend);
4945}
e0001a05 4946
e0001a05 4947
43cd72b9 4948static struct elf_link_hash_entry *
7fa3d080 4949r_reloc_get_hash_entry (const r_reloc *r_rel)
e0001a05 4950{
43cd72b9
BW		 4951 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4952 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4953}
e0001a05 4954
43cd72b9
BW		 4955
4956static asection *
7fa3d080 4957r_reloc_get_section (const r_reloc *r_rel)
43cd72b9
BW		 4958{
4959 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4960 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4961}
e0001a05
NC		 4962
4963
4964static bfd_boolean
7fa3d080 4965r_reloc_is_defined (const r_reloc *r_rel)
e0001a05 4966{
43cd72b9
BW		 4967 asection *sec;
4968 if (r_rel == NULL)
e0001a05 4969 return FALSE;
e0001a05 4970
43cd72b9
BW		 4971 sec = r_reloc_get_section (r_rel);
4972 if (sec == bfd_abs_section_ptr
4973 || sec == bfd_com_section_ptr
4974 || sec == bfd_und_section_ptr)
4975 return FALSE;
4976 return TRUE;
e0001a05
NC		 4977}
4978
4979
7fa3d080
BW		 4980static void
4981r_reloc_init (r_reloc *r_rel,
4982 bfd *abfd,
4983 Elf_Internal_Rela *irel,
4984 bfd_byte *contents,
4985 bfd_size_type content_length)
4986{
4987 int r_type;
4988 reloc_howto_type *howto;
4989
4990 if (irel)
4991 {
4992 r_rel->rela = *irel;
4993 r_rel->abfd = abfd;
4994 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4995 r_rel->virtual_offset = 0;
4996 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4997 howto = &elf_howto_table[r_type];
4998 if (howto->partial_inplace)
4999 {
5000 bfd_vma inplace_val;
5001 BFD_ASSERT (r_rel->rela.r_offset < content_length);
5002
5003 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5004 r_rel->target_offset += inplace_val;
5005 }
5006 }
5007 else
5008 memset (r_rel, 0, sizeof (r_reloc));
5009}
5010
5011
43cd72b9
BW		 5012#if DEBUG
5013
e0001a05 5014static void
7fa3d080 5015print_r_reloc (FILE *fp, const r_reloc *r_rel)
e0001a05 5016{
43cd72b9
BW		 5017 if (r_reloc_is_defined (r_rel))
5018 {
5019 asection *sec = r_reloc_get_section (r_rel);
5020 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5021 }
5022 else if (r_reloc_get_hash_entry (r_rel))
5023 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5024 else
5025 fprintf (fp, " ?? + ");
e0001a05 5026
43cd72b9
BW		 5027 fprintf_vma (fp, r_rel->target_offset);
5028 if (r_rel->virtual_offset)
5029 {
5030 fprintf (fp, " + ");
5031 fprintf_vma (fp, r_rel->virtual_offset);
5032 }
5033
5034 fprintf (fp, ")");
5035}
e0001a05 5036
43cd72b9 5037#endif /* DEBUG */
e0001a05 5038
43cd72b9
BW		 5039\f
5040/* source_reloc: relocations that reference literals. */
e0001a05 5041
43cd72b9
BW		 5042/* To determine whether literals can be coalesced, we need to first
5043 record all the relocations that reference the literals. The
5044 source_reloc structure below is used for this purpose. The
5045 source_reloc entries are kept in a per-literal-section array, sorted
5046 by offset within the literal section (i.e., target offset).
e0001a05 5047
43cd72b9
BW		 5048 The source_sec and r_rel.rela.r_offset fields identify the source of
5049 the relocation. The r_rel field records the relocation value, i.e.,
5050 the offset of the literal being referenced. The opnd field is needed
5051 to determine the range of the immediate field to which the relocation
5052 applies, so we can determine whether another literal with the same
5053 value is within range. The is_null field is true when the relocation
5054 is being removed (e.g., when an L32R is being removed due to a CALLX
5055 that is converted to a direct CALL). */
e0001a05 5056
43cd72b9
BW		 5057typedef struct source_reloc_struct source_reloc;
5058
5059struct source_reloc_struct
e0001a05 5060{
43cd72b9
BW		 5061 asection *source_sec;
5062 r_reloc r_rel;
5063 xtensa_opcode opcode;
5064 int opnd;
5065 bfd_boolean is_null;
5066 bfd_boolean is_abs_literal;
5067};
e0001a05 5068
e0001a05 5069
e0001a05 5070static void
7fa3d080
BW		 5071init_source_reloc (source_reloc *reloc,
5072 asection *source_sec,
5073 const r_reloc *r_rel,
5074 xtensa_opcode opcode,
5075 int opnd,
5076 bfd_boolean is_abs_literal)
e0001a05 5077{
43cd72b9
BW		 5078 reloc->source_sec = source_sec;
5079 reloc->r_rel = *r_rel;
5080 reloc->opcode = opcode;
5081 reloc->opnd = opnd;
5082 reloc->is_null = FALSE;
5083 reloc->is_abs_literal = is_abs_literal;
e0001a05
NC		 5084}
5085
e0001a05 5086
43cd72b9
BW		 5087/* Find the source_reloc for a particular source offset and relocation
5088 type. Note that the array is sorted by _target_ offset, so this is
5089 just a linear search. */
e0001a05 5090
43cd72b9 5091static source_reloc *
7fa3d080
BW		 5092find_source_reloc (source_reloc *src_relocs,
5093 int src_count,
5094 asection *sec,
5095 Elf_Internal_Rela *irel)
e0001a05 5096{
43cd72b9 5097 int i;
e0001a05 5098
43cd72b9
BW		 5099 for (i = 0; i < src_count; i++)
5100 {
5101 if (src_relocs[i].source_sec == sec
5102 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5103 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5104 == ELF32_R_TYPE (irel->r_info)))
5105 return &src_relocs[i];
5106 }
e0001a05 5107
43cd72b9 5108 return NULL;
e0001a05
NC		 5109}
5110
5111
43cd72b9 5112static int
7fa3d080 5113source_reloc_compare (const void *ap, const void *bp)
e0001a05 5114{
43cd72b9
BW		 5115 const source_reloc *a = (const source_reloc *) ap;
5116 const source_reloc *b = (const source_reloc *) bp;
e0001a05 5117
43cd72b9
BW		 5118 if (a->r_rel.target_offset != b->r_rel.target_offset)
5119 return (a->r_rel.target_offset - b->r_rel.target_offset);
e0001a05 5120
43cd72b9
BW		 5121 /* We don't need to sort on these criteria for correctness,
5122 but enforcing a more strict ordering prevents unstable qsort
5123 from behaving differently with different implementations.
5124 Without the code below we get correct but different results
5125 on Solaris 2.7 and 2.8. We would like to always produce the
5126 same results no matter the host. */
5127
5128 if ((!a->is_null) - (!b->is_null))
5129 return ((!a->is_null) - (!b->is_null));
5130 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
e0001a05
NC		 5131}
5132
43cd72b9
BW		 5133\f
5134/* Literal values and value hash tables. */
e0001a05 5135
43cd72b9
BW		 5136/* Literals with the same value can be coalesced. The literal_value
5137 structure records the value of a literal: the "r_rel" field holds the
5138 information from the relocation on the literal (if there is one) and
5139 the "value" field holds the contents of the literal word itself.
e0001a05 5140
43cd72b9
BW		 5141 The value_map structure records a literal value along with the
5142 location of a literal holding that value. The value_map hash table
5143 is indexed by the literal value, so that we can quickly check if a
5144 particular literal value has been seen before and is thus a candidate
5145 for coalescing. */
e0001a05 5146
43cd72b9
BW		 5147typedef struct literal_value_struct literal_value;
5148typedef struct value_map_struct value_map;
5149typedef struct value_map_hash_table_struct value_map_hash_table;
e0001a05 5150
43cd72b9 5151struct literal_value_struct
e0001a05 5152{
43cd72b9
BW		 5153 r_reloc r_rel;
5154 unsigned long value;
5155 bfd_boolean is_abs_literal;
5156};
5157
5158struct value_map_struct
5159{
5160 literal_value val; /* The literal value. */
5161 r_reloc loc; /* Location of the literal. */
5162 value_map *next;
5163};
5164
5165struct value_map_hash_table_struct
5166{
5167 unsigned bucket_count;
5168 value_map **buckets;
5169 unsigned count;
5170 bfd_boolean has_last_loc;
5171 r_reloc last_loc;
5172};
5173
5174
e0001a05 5175static void
7fa3d080
BW		 5176init_literal_value (literal_value *lit,
5177 const r_reloc *r_rel,
5178 unsigned long value,
5179 bfd_boolean is_abs_literal)
e0001a05 5180{
43cd72b9
BW		 5181 lit->r_rel = *r_rel;
5182 lit->value = value;
5183 lit->is_abs_literal = is_abs_literal;
e0001a05
NC		 5184}
5185
5186
43cd72b9 5187static bfd_boolean
7fa3d080
BW		 5188literal_value_equal (const literal_value *src1,
5189 const literal_value *src2,
5190 bfd_boolean final_static_link)
e0001a05 5191{
43cd72b9 5192 struct elf_link_hash_entry *h1, *h2;
e0001a05 5193
43cd72b9
BW		 5194 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5195 return FALSE;
e0001a05 5196
43cd72b9
BW		 5197 if (r_reloc_is_const (&src1->r_rel))
5198 return (src1->value == src2->value);
e0001a05 5199
43cd72b9
BW		 5200 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5201 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5202 return FALSE;
e0001a05 5203
43cd72b9
BW		 5204 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5205 return FALSE;
5206
5207 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5208 return FALSE;
5209
5210 if (src1->value != src2->value)
5211 return FALSE;
5212
5213 /* Now check for the same section (if defined) or the same elf_hash
5214 (if undefined or weak). */
5215 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5216 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5217 if (r_reloc_is_defined (&src1->r_rel)
5218 && (final_static_link
5219 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5220 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5221 {
5222 if (r_reloc_get_section (&src1->r_rel)
5223 != r_reloc_get_section (&src2->r_rel))
5224 return FALSE;
5225 }
5226 else
5227 {
5228 /* Require that the hash entries (i.e., symbols) be identical. */
5229 if (h1 != h2 || h1 == 0)
5230 return FALSE;
5231 }
5232
5233 if (src1->is_abs_literal != src2->is_abs_literal)
5234 return FALSE;
5235
5236 return TRUE;
e0001a05
NC		 5237}
5238
e0001a05 5239
43cd72b9
BW		 5240/* Must be power of 2. */
5241#define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
e0001a05 5242
43cd72b9 5243static value_map_hash_table *
7fa3d080 5244value_map_hash_table_init (void)
43cd72b9
BW		 5245{
5246 value_map_hash_table *values;
e0001a05 5247
43cd72b9
BW		 5248 values = (value_map_hash_table *)
5249 bfd_zmalloc (sizeof (value_map_hash_table));
5250 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5251 values->count = 0;
5252 values->buckets = (value_map **)
5253 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5254 if (values->buckets == NULL)
5255 {
5256 free (values);
5257 return NULL;
5258 }
5259 values->has_last_loc = FALSE;
5260
5261 return values;
5262}
5263
5264
5265static void
7fa3d080 5266value_map_hash_table_delete (value_map_hash_table *table)
e0001a05 5267{
43cd72b9
BW		 5268 free (table->buckets);
5269 free (table);
5270}
5271
5272
5273static unsigned
7fa3d080 5274hash_bfd_vma (bfd_vma val)
43cd72b9
BW		 5275{
5276 return (val >> 2) + (val >> 10);
5277}
5278
5279
5280static unsigned
7fa3d080 5281literal_value_hash (const literal_value *src)
43cd72b9
BW		 5282{
5283 unsigned hash_val;
e0001a05 5284
43cd72b9
BW		 5285 hash_val = hash_bfd_vma (src->value);
5286 if (!r_reloc_is_const (&src->r_rel))
e0001a05 5287 {
43cd72b9
BW		 5288 void *sec_or_hash;
5289
5290 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5291 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5292 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5293
5294 /* Now check for the same section and the same elf_hash. */
5295 if (r_reloc_is_defined (&src->r_rel))
5296 sec_or_hash = r_reloc_get_section (&src->r_rel);
5297 else
5298 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
f60ca5e3 5299 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
e0001a05 5300 }
43cd72b9
BW		 5301 return hash_val;
5302}
e0001a05 5303
e0001a05 5304
43cd72b9 5305/* Check if the specified literal_value has been seen before. */
e0001a05 5306
43cd72b9 5307static value_map *
7fa3d080
BW		 5308value_map_get_cached_value (value_map_hash_table *map,
5309 const literal_value *val,
5310 bfd_boolean final_static_link)
43cd72b9
BW		 5311{
5312 value_map *map_e;
5313 value_map *bucket;
5314 unsigned idx;
5315
5316 idx = literal_value_hash (val);
5317 idx = idx & (map->bucket_count - 1);
5318 bucket = map->buckets[idx];
5319 for (map_e = bucket; map_e; map_e = map_e->next)
e0001a05 5320 {
43cd72b9
BW		 5321 if (literal_value_equal (&map_e->val, val, final_static_link))
5322 return map_e;
5323 }
5324 return NULL;
5325}
e0001a05 5326
e0001a05 5327
43cd72b9
BW		 5328/* Record a new literal value. It is illegal to call this if VALUE
5329 already has an entry here. */
5330
5331static value_map *
7fa3d080
BW		 5332add_value_map (value_map_hash_table *map,
5333 const literal_value *val,
5334 const r_reloc *loc,
5335 bfd_boolean final_static_link)
43cd72b9
BW		 5336{
5337 value_map **bucket_p;
5338 unsigned idx;
5339
5340 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5341 if (val_e == NULL)
5342 {
5343 bfd_set_error (bfd_error_no_memory);
5344 return NULL;
e0001a05
NC		 5345 }
5346
43cd72b9
BW		 5347 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5348 val_e->val = *val;
5349 val_e->loc = *loc;
5350
5351 idx = literal_value_hash (val);
5352 idx = idx & (map->bucket_count - 1);
5353 bucket_p = &map->buckets[idx];
5354
5355 val_e->next = *bucket_p;
5356 *bucket_p = val_e;
5357 map->count++;
5358 /* FIXME: Consider resizing the hash table if we get too many entries. */
5359
5360 return val_e;
e0001a05
NC		 5361}
5362
43cd72b9
BW		 5363\f
5364/* Lists of text actions (ta_) for narrowing, widening, longcall
5365 conversion, space fill, code & literal removal, etc. */
5366
5367/* The following text actions are generated:
5368
5369 "ta_remove_insn" remove an instruction or instructions
5370 "ta_remove_longcall" convert longcall to call
5371 "ta_convert_longcall" convert longcall to nop/call
5372 "ta_narrow_insn" narrow a wide instruction
5373 "ta_widen" widen a narrow instruction
5374 "ta_fill" add fill or remove fill
5375 removed < 0 is a fill; branches to the fill address will be
5376 changed to address + fill size (e.g., address - removed)
5377 removed >= 0 branches to the fill address will stay unchanged
5378 "ta_remove_literal" remove a literal; this action is
5379 indicated when a literal is removed
5380 or replaced.
5381 "ta_add_literal" insert a new literal; this action is
5382 indicated when a literal has been moved.
5383 It may use a virtual_offset because
5384 multiple literals can be placed at the
5385 same location.
5386
5387 For each of these text actions, we also record the number of bytes
5388 removed by performing the text action. In the case of a "ta_widen"
5389 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5390
5391typedef struct text_action_struct text_action;
5392typedef struct text_action_list_struct text_action_list;
5393typedef enum text_action_enum_t text_action_t;
5394
5395enum text_action_enum_t
5396{
5397 ta_none,
5398 ta_remove_insn, /* removed = -size */
5399 ta_remove_longcall, /* removed = -size */
5400 ta_convert_longcall, /* removed = 0 */
5401 ta_narrow_insn, /* removed = -1 */
5402 ta_widen_insn, /* removed = +1 */
5403 ta_fill, /* removed = +size */
5404 ta_remove_literal,
5405 ta_add_literal
5406};
e0001a05 5407
e0001a05 5408
43cd72b9
BW		 5409/* Structure for a text action record. */
5410struct text_action_struct
e0001a05 5411{
43cd72b9
BW		 5412 text_action_t action;
5413 asection *sec; /* Optional */
5414 bfd_vma offset;
5415 bfd_vma virtual_offset; /* Zero except for adding literals. */
5416 int removed_bytes;
5417 literal_value value; /* Only valid when adding literals. */
e0001a05 5418
43cd72b9
BW		 5419 text_action *next;
5420};
e0001a05 5421
e0001a05 5422
43cd72b9
BW		 5423/* List of all of the actions taken on a text section. */
5424struct text_action_list_struct
5425{
5426 text_action *head;
5427};
e0001a05 5428
e0001a05 5429
7fa3d080
BW		 5430static text_action *
5431find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
43cd72b9
BW		 5432{
5433 text_action **m_p;
5434
5435 /* It is not necessary to fill at the end of a section. */
5436 if (sec->size == offset)
5437 return NULL;
5438
7fa3d080 5439 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
43cd72b9
BW		 5440 {
5441 text_action *t = *m_p;
5442 /* When the action is another fill at the same address,
5443 just increase the size. */
5444 if (t->offset == offset && t->action == ta_fill)
5445 return t;
5446 }
5447 return NULL;
5448}
5449
5450
5451static int
7fa3d080
BW		 5452compute_removed_action_diff (const text_action *ta,
5453 asection *sec,
5454 bfd_vma offset,
5455 int removed,
5456 int removable_space)
43cd72b9
BW		 5457{
5458 int new_removed;
5459 int current_removed = 0;
5460
7fa3d080 5461 if (ta)
43cd72b9
BW		 5462 current_removed = ta->removed_bytes;
5463
5464 BFD_ASSERT (ta == NULL || ta->offset == offset);
5465 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5466
5467 /* It is not necessary to fill at the end of a section. Clean this up. */
5468 if (sec->size == offset)
5469 new_removed = removable_space - 0;
5470 else
5471 {
5472 int space;
5473 int added = -removed - current_removed;
5474 /* Ignore multiples of the section alignment. */
5475 added = ((1 << sec->alignment_power) - 1) & added;
5476 new_removed = (-added);
5477
5478 /* Modify for removable. */
5479 space = removable_space - new_removed;
5480 new_removed = (removable_space
5481 - (((1 << sec->alignment_power) - 1) & space));
5482 }
5483 return (new_removed - current_removed);
5484}
5485
5486
7fa3d080
BW		 5487static void
5488adjust_fill_action (text_action *ta, int fill_diff)
43cd72b9
BW		 5489{
5490 ta->removed_bytes += fill_diff;
5491}
5492
5493
5494/* Add a modification action to the text. For the case of adding or
5495 removing space, modify any current fill and assume that
5496 "unreachable_space" bytes can be freely contracted. Note that a
5497 negative removed value is a fill. */
5498
5499static void
7fa3d080
BW		 5500text_action_add (text_action_list *l,
5501 text_action_t action,
5502 asection *sec,
5503 bfd_vma offset,
5504 int removed)
43cd72b9
BW		 5505{
5506 text_action **m_p;
5507 text_action *ta;
5508
5509 /* It is not necessary to fill at the end of a section. */
5510 if (action == ta_fill && sec->size == offset)
5511 return;
5512
5513 /* It is not necessary to fill 0 bytes. */
5514 if (action == ta_fill && removed == 0)
5515 return;
5516
7fa3d080 5517 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
43cd72b9
BW		 5518 {
5519 text_action *t = *m_p;
658ff993
SA		 5520
5521 if (action == ta_fill)
43cd72b9 5522 {
658ff993
SA		 5523 /* When the action is another fill at the same address,
5524 just increase the size. */
5525 if (t->offset == offset && t->action == ta_fill)
5526 {
5527 t->removed_bytes += removed;
5528 return;
5529 }
5530 /* Fills need to happen before widens so that we don't
5531 insert fill bytes into the instruction stream. */
5532 if (t->offset == offset && t->action == ta_widen_insn)
5533 break;
43cd72b9
BW		 5534 }
5535 }
5536
5537 /* Create a new record and fill it up. */
5538 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5539 ta->action = action;
5540 ta->sec = sec;
5541 ta->offset = offset;
5542 ta->removed_bytes = removed;
5543 ta->next = (*m_p);
5544 *m_p = ta;
5545}
5546
5547
5548static void
7fa3d080
BW		 5549text_action_add_literal (text_action_list *l,
5550 text_action_t action,
5551 const r_reloc *loc,
5552 const literal_value *value,
5553 int removed)
43cd72b9
BW		 5554{
5555 text_action **m_p;
5556 text_action *ta;
5557 asection *sec = r_reloc_get_section (loc);
5558 bfd_vma offset = loc->target_offset;
5559 bfd_vma virtual_offset = loc->virtual_offset;
5560
5561 BFD_ASSERT (action == ta_add_literal);
5562
5563 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
5564 {
5565 if ((*m_p)->offset > offset
5566 && ((*m_p)->offset != offset
5567 || (*m_p)->virtual_offset > virtual_offset))
5568 break;
5569 }
5570
5571 /* Create a new record and fill it up. */
5572 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5573 ta->action = action;
5574 ta->sec = sec;
5575 ta->offset = offset;
5576 ta->virtual_offset = virtual_offset;
5577 ta->value = *value;
5578 ta->removed_bytes = removed;
5579 ta->next = (*m_p);
5580 *m_p = ta;
5581}
5582
5583
03669f1c
BW		 5584/* Find the total offset adjustment for the relaxations specified by
5585 text_actions, beginning from a particular starting action. This is
5586 typically used from offset_with_removed_text to search an entire list of
5587 actions, but it may also be called directly when adjusting adjacent offsets
5588 so that each search may begin where the previous one left off. */
5589
5590static int
5591removed_by_actions (text_action **p_start_action,
5592 bfd_vma offset,
5593 bfd_boolean before_fill)
43cd72b9
BW		 5594{
5595 text_action *r;
5596 int removed = 0;
5597
03669f1c
BW		 5598 r = *p_start_action;
5599 while (r)
43cd72b9 5600 {
03669f1c
BW		 5601 if (r->offset > offset)
5602 break;
5603
5604 if (r->offset == offset
5605 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5606 break;
5607
5608 removed += r->removed_bytes;
5609
5610 r = r->next;
43cd72b9
BW		 5611 }
5612
03669f1c
BW		 5613 *p_start_action = r;
5614 return removed;
5615}
5616
5617
5618static bfd_vma
5619offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5620{
5621 text_action *r = action_list->head;
5622 return offset - removed_by_actions (&r, offset, FALSE);
43cd72b9
BW		 5623}
5624
5625
03e94c08
BW		 5626static unsigned
5627action_list_count (text_action_list *action_list)
5628{
5629 text_action *r = action_list->head;
5630 unsigned count = 0;
5631 for (r = action_list->head; r != NULL; r = r->next)
5632 {
5633 count++;
5634 }
5635 return count;
5636}
5637
5638
43cd72b9
BW		 5639/* The find_insn_action routine will only find non-fill actions. */
5640
7fa3d080
BW		 5641static text_action *
5642find_insn_action (text_action_list *action_list, bfd_vma offset)
43cd72b9
BW		 5643{
5644 text_action *t;
5645 for (t = action_list->head; t; t = t->next)
5646 {
5647 if (t->offset == offset)
5648 {
5649 switch (t->action)
5650 {
5651 case ta_none:
5652 case ta_fill:
5653 break;
5654 case ta_remove_insn:
5655 case ta_remove_longcall:
5656 case ta_convert_longcall:
5657 case ta_narrow_insn:
5658 case ta_widen_insn:
5659 return t;
5660 case ta_remove_literal:
5661 case ta_add_literal:
5662 BFD_ASSERT (0);
5663 break;
5664 }
5665 }
5666 }
5667 return NULL;
5668}
5669
5670
5671#if DEBUG
5672
5673static void
7fa3d080 5674print_action_list (FILE *fp, text_action_list *action_list)
43cd72b9
BW		 5675{
5676 text_action *r;
5677
5678 fprintf (fp, "Text Action\n");
5679 for (r = action_list->head; r != NULL; r = r->next)
5680 {
5681 const char *t = "unknown";
5682 switch (r->action)
5683 {
5684 case ta_remove_insn:
5685 t = "remove_insn"; break;
5686 case ta_remove_longcall:
5687 t = "remove_longcall"; break;
5688 case ta_convert_longcall:
c46082c8 5689 t = "convert_longcall"; break;
43cd72b9
BW		 5690 case ta_narrow_insn:
5691 t = "narrow_insn"; break;
5692 case ta_widen_insn:
5693 t = "widen_insn"; break;
5694 case ta_fill:
5695 t = "fill"; break;
5696 case ta_none:
5697 t = "none"; break;
5698 case ta_remove_literal:
5699 t = "remove_literal"; break;
5700 case ta_add_literal:
5701 t = "add_literal"; break;
5702 }
5703
5704 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5705 r->sec->owner->filename,
9ccb8af9 5706 r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
43cd72b9
BW		 5707 }
5708}
5709
5710#endif /* DEBUG */
5711
5712\f
5713/* Lists of literals being coalesced or removed. */
5714
5715/* In the usual case, the literal identified by "from" is being
5716 coalesced with another literal identified by "to". If the literal is
5717 unused and is being removed altogether, "to.abfd" will be NULL.
5718 The removed_literal entries are kept on a per-section list, sorted
5719 by the "from" offset field. */
5720
5721typedef struct removed_literal_struct removed_literal;
5722typedef struct removed_literal_list_struct removed_literal_list;
5723
5724struct removed_literal_struct
5725{
5726 r_reloc from;
5727 r_reloc to;
5728 removed_literal *next;
5729};
5730
5731struct removed_literal_list_struct
5732{
5733 removed_literal *head;
5734 removed_literal *tail;
5735};
5736
5737
43cd72b9
BW		 5738/* Record that the literal at "from" is being removed. If "to" is not
5739 NULL, the "from" literal is being coalesced with the "to" literal. */
5740
5741static void
7fa3d080
BW		 5742add_removed_literal (removed_literal_list *removed_list,
5743 const r_reloc *from,
5744 const r_reloc *to)
43cd72b9
BW		 5745{
5746 removed_literal *r, *new_r, *next_r;
5747
5748 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5749
5750 new_r->from = *from;
5751 if (to)
5752 new_r->to = *to;
5753 else
5754 new_r->to.abfd = NULL;
5755 new_r->next = NULL;
5756
5757 r = removed_list->head;
5758 if (r == NULL)
5759 {
5760 removed_list->head = new_r;
5761 removed_list->tail = new_r;
5762 }
5763 /* Special check for common case of append. */
5764 else if (removed_list->tail->from.target_offset < from->target_offset)
5765 {
5766 removed_list->tail->next = new_r;
5767 removed_list->tail = new_r;
5768 }
5769 else
5770 {
7fa3d080 5771 while (r->from.target_offset < from->target_offset && r->next)
43cd72b9
BW		 5772 {
5773 r = r->next;
5774 }
5775 next_r = r->next;
5776 r->next = new_r;
5777 new_r->next = next_r;
5778 if (next_r == NULL)
5779 removed_list->tail = new_r;
5780 }
5781}
5782
5783
5784/* Check if the list of removed literals contains an entry for the
5785 given address. Return the entry if found. */
5786
5787static removed_literal *
7fa3d080 5788find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
43cd72b9
BW		 5789{
5790 removed_literal *r = removed_list->head;
5791 while (r && r->from.target_offset < addr)
5792 r = r->next;
5793 if (r && r->from.target_offset == addr)
5794 return r;
5795 return NULL;
5796}
5797
5798
5799#if DEBUG
5800
5801static void
7fa3d080 5802print_removed_literals (FILE *fp, removed_literal_list *removed_list)
43cd72b9
BW		 5803{
5804 removed_literal *r;
5805 r = removed_list->head;
5806 if (r)
5807 fprintf (fp, "Removed Literals\n");
5808 for (; r != NULL; r = r->next)
5809 {
5810 print_r_reloc (fp, &r->from);
5811 fprintf (fp, " => ");
5812 if (r->to.abfd == NULL)
5813 fprintf (fp, "REMOVED");
5814 else
5815 print_r_reloc (fp, &r->to);
5816 fprintf (fp, "\n");
5817 }
5818}
5819
5820#endif /* DEBUG */
5821
5822\f
5823/* Per-section data for relaxation. */
5824
5825typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5826
5827struct xtensa_relax_info_struct
5828{
5829 bfd_boolean is_relaxable_literal_section;
5830 bfd_boolean is_relaxable_asm_section;
5831 int visited; /* Number of times visited. */
5832
5833 source_reloc *src_relocs; /* Array[src_count]. */
5834 int src_count;
5835 int src_next; /* Next src_relocs entry to assign. */
5836
5837 removed_literal_list removed_list;
5838 text_action_list action_list;
5839
5840 reloc_bfd_fix *fix_list;
5841 reloc_bfd_fix *fix_array;
5842 unsigned fix_array_count;
5843
5844 /* Support for expanding the reloc array that is stored
5845 in the section structure. If the relocations have been
5846 reallocated, the newly allocated relocations will be referenced
5847 here along with the actual size allocated. The relocation
5848 count will always be found in the section structure. */
5849 Elf_Internal_Rela *allocated_relocs;
5850 unsigned relocs_count;
5851 unsigned allocated_relocs_count;
5852};
5853
5854struct elf_xtensa_section_data
5855{
5856 struct bfd_elf_section_data elf;
5857 xtensa_relax_info relax_info;
5858};
5859
43cd72b9
BW		 5860
5861static bfd_boolean
7fa3d080 5862elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
43cd72b9 5863{
f592407e
AM		 5864 if (!sec->used_by_bfd)
5865 {
5866 struct elf_xtensa_section_data *sdata;
5867 bfd_size_type amt = sizeof (*sdata);
43cd72b9 5868
f592407e
AM		 5869 sdata = bfd_zalloc (abfd, amt);
5870 if (sdata == NULL)
5871 return FALSE;
5872 sec->used_by_bfd = sdata;
5873 }
43cd72b9
BW		 5874
5875 return _bfd_elf_new_section_hook (abfd, sec);
5876}
5877
5878
7fa3d080
BW		 5879static xtensa_relax_info *
5880get_xtensa_relax_info (asection *sec)
5881{
5882 struct elf_xtensa_section_data *section_data;
5883
5884 /* No info available if no section or if it is an output section. */
5885 if (!sec || sec == sec->output_section)
5886 return NULL;
5887
5888 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5889 return &section_data->relax_info;
5890}
5891
5892
43cd72b9 5893static void
7fa3d080 5894init_xtensa_relax_info (asection *sec)
43cd72b9
BW		 5895{
5896 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5897
5898 relax_info->is_relaxable_literal_section = FALSE;
5899 relax_info->is_relaxable_asm_section = FALSE;
5900 relax_info->visited = 0;
5901
5902 relax_info->src_relocs = NULL;
5903 relax_info->src_count = 0;
5904 relax_info->src_next = 0;
5905
5906 relax_info->removed_list.head = NULL;
5907 relax_info->removed_list.tail = NULL;
5908
5909 relax_info->action_list.head = NULL;
5910
5911 relax_info->fix_list = NULL;
5912 relax_info->fix_array = NULL;
5913 relax_info->fix_array_count = 0;
5914
5915 relax_info->allocated_relocs = NULL;
5916 relax_info->relocs_count = 0;
5917 relax_info->allocated_relocs_count = 0;
5918}
5919
43cd72b9
BW		 5920\f
5921/* Coalescing literals may require a relocation to refer to a section in
5922 a different input file, but the standard relocation information
5923 cannot express that. Instead, the reloc_bfd_fix structures are used
5924 to "fix" the relocations that refer to sections in other input files.
5925 These structures are kept on per-section lists. The "src_type" field
5926 records the relocation type in case there are multiple relocations on
5927 the same location. FIXME: This is ugly; an alternative might be to
5928 add new symbols with the "owner" field to some other input file. */
5929
5930struct reloc_bfd_fix_struct
5931{
5932 asection *src_sec;
5933 bfd_vma src_offset;
5934 unsigned src_type; /* Relocation type. */
5935
43cd72b9
BW		 5936 asection *target_sec;
5937 bfd_vma target_offset;
5938 bfd_boolean translated;
5939
5940 reloc_bfd_fix *next;
5941};
5942
5943
43cd72b9 5944static reloc_bfd_fix *
7fa3d080
BW		 5945reloc_bfd_fix_init (asection *src_sec,
5946 bfd_vma src_offset,
5947 unsigned src_type,
7fa3d080
BW		 5948 asection *target_sec,
5949 bfd_vma target_offset,
5950 bfd_boolean translated)
43cd72b9
BW		 5951{
5952 reloc_bfd_fix *fix;
5953
5954 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5955 fix->src_sec = src_sec;
5956 fix->src_offset = src_offset;
5957 fix->src_type = src_type;
43cd72b9
BW		 5958 fix->target_sec = target_sec;
5959 fix->target_offset = target_offset;
5960 fix->translated = translated;
5961
5962 return fix;
5963}
5964
5965
5966static void
7fa3d080 5967add_fix (asection *src_sec, reloc_bfd_fix *fix)
43cd72b9
BW		 5968{
5969 xtensa_relax_info *relax_info;
5970
5971 relax_info = get_xtensa_relax_info (src_sec);
5972 fix->next = relax_info->fix_list;
5973 relax_info->fix_list = fix;
5974}
5975
5976
5977static int
7fa3d080 5978fix_compare (const void *ap, const void *bp)
43cd72b9
BW		 5979{
5980 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5981 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5982
5983 if (a->src_offset != b->src_offset)
5984 return (a->src_offset - b->src_offset);
5985 return (a->src_type - b->src_type);
5986}
5987
5988
5989static void
7fa3d080 5990cache_fix_array (asection *sec)
43cd72b9
BW		 5991{
5992 unsigned i, count = 0;
5993 reloc_bfd_fix *r;
5994 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5995
5996 if (relax_info == NULL)
5997 return;
5998 if (relax_info->fix_list == NULL)
5999 return;
6000
6001 for (r = relax_info->fix_list; r != NULL; r = r->next)
6002 count++;
6003
6004 relax_info->fix_array =
6005 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6006 relax_info->fix_array_count = count;
6007
6008 r = relax_info->fix_list;
6009 for (i = 0; i < count; i++, r = r->next)
6010 {
6011 relax_info->fix_array[count - 1 - i] = *r;
6012 relax_info->fix_array[count - 1 - i].next = NULL;
6013 }
6014
6015 qsort (relax_info->fix_array, relax_info->fix_array_count,
6016 sizeof (reloc_bfd_fix), fix_compare);
6017}
6018
6019
6020static reloc_bfd_fix *
7fa3d080 6021get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
43cd72b9
BW		 6022{
6023 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6024 reloc_bfd_fix *rv;
6025 reloc_bfd_fix key;
6026
6027 if (relax_info == NULL)
6028 return NULL;
6029 if (relax_info->fix_list == NULL)
6030 return NULL;
6031
6032 if (relax_info->fix_array == NULL)
6033 cache_fix_array (sec);
6034
6035 key.src_offset = offset;
6036 key.src_type = type;
6037 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6038 sizeof (reloc_bfd_fix), fix_compare);
6039 return rv;
6040}
6041
6042\f
6043/* Section caching. */
6044
6045typedef struct section_cache_struct section_cache_t;
6046
6047struct section_cache_struct
6048{
6049 asection *sec;
6050
6051 bfd_byte *contents; /* Cache of the section contents. */
6052 bfd_size_type content_length;
6053
6054 property_table_entry *ptbl; /* Cache of the section property table. */
6055 unsigned pte_count;
6056
6057 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6058 unsigned reloc_count;
6059};
6060
6061
7fa3d080
BW		 6062static void
6063init_section_cache (section_cache_t *sec_cache)
6064{
6065 memset (sec_cache, 0, sizeof (*sec_cache));
6066}
43cd72b9
BW		 6067
6068
6069static void
65e911f9 6070free_section_cache (section_cache_t *sec_cache)
43cd72b9 6071{
7fa3d080
BW		 6072 if (sec_cache->sec)
6073 {
6074 release_contents (sec_cache->sec, sec_cache->contents);
6075 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6076 if (sec_cache->ptbl)
6077 free (sec_cache->ptbl);
7fa3d080 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. */
65e911f9
AM		 6118 free_section_cache (sec_cache);
6119 init_section_cache (sec_cache);
43cd72b9
BW		 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:
65e911f9
AM		 8274 if (prop_table)
8275 free (prop_table);
8276 free_section_cache (&target_sec_cache);
43cd72b9
BW		 8277
8278 release_contents (sec, contents);
8279 release_internal_relocs (sec, internal_relocs);
8280 return ok;
8281}
8282
8283
8284static Elf_Internal_Rela *
7fa3d080
BW		 8285get_irel_at_offset (asection *sec,
8286 Elf_Internal_Rela *internal_relocs,
8287 bfd_vma offset)
43cd72b9
BW		 8288{
8289 unsigned i;
8290 Elf_Internal_Rela *irel;
8291 unsigned r_type;
8292 Elf_Internal_Rela key;
8293
8294 if (!internal_relocs)
8295 return NULL;
8296
8297 key.r_offset = offset;
8298 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8299 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8300 if (!irel)
8301 return NULL;
8302
8303 /* bsearch does not guarantee which will be returned if there are
8304 multiple matches. We need the first that is not an alignment. */
8305 i = irel - internal_relocs;
8306 while (i > 0)
8307 {
8308 if (internal_relocs[i-1].r_offset != offset)
8309 break;
8310 i--;
8311 }
8312 for ( ; i < sec->reloc_count; i++)
8313 {
8314 irel = &internal_relocs[i];
8315 r_type = ELF32_R_TYPE (irel->r_info);
8316 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8317 return irel;
8318 }
8319
8320 return NULL;
8321}
8322
8323
8324bfd_boolean
7fa3d080
BW		 8325is_removable_literal (const source_reloc *rel,
8326 int i,
8327 const source_reloc *src_relocs,
99ded152
BW		 8328 int src_count,
8329 asection *sec,
8330 property_table_entry *prop_table,
8331 int ptblsize)
43cd72b9
BW		 8332{
8333 const source_reloc *curr_rel;
99ded152
BW		 8334 property_table_entry *entry;
8335
43cd72b9
BW		 8336 if (!rel->is_null)
8337 return FALSE;
8338
99ded152
BW		 8339 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8340 sec->vma + rel->r_rel.target_offset);
8341 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8342 return FALSE;
8343
43cd72b9
BW		 8344 for (++i; i < src_count; ++i)
8345 {
8346 curr_rel = &src_relocs[i];
8347 /* If all others have the same target offset.... */
8348 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8349 return TRUE;
8350
8351 if (!curr_rel->is_null
8352 && !xtensa_is_property_section (curr_rel->source_sec)
8353 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8354 return FALSE;
8355 }
8356 return TRUE;
8357}
8358
8359
8360bfd_boolean
7fa3d080
BW		 8361remove_dead_literal (bfd *abfd,
8362 asection *sec,
8363 struct bfd_link_info *link_info,
8364 Elf_Internal_Rela *internal_relocs,
8365 Elf_Internal_Rela *irel,
8366 source_reloc *rel,
8367 property_table_entry *prop_table,
8368 int ptblsize)
43cd72b9
BW		 8369{
8370 property_table_entry *entry;
8371 xtensa_relax_info *relax_info;
8372
8373 relax_info = get_xtensa_relax_info (sec);
8374 if (!relax_info)
8375 return FALSE;
8376
8377 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8378 sec->vma + rel->r_rel.target_offset);
8379
8380 /* Mark the unused literal so that it will be removed. */
8381 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8382
8383 text_action_add (&relax_info->action_list,
8384 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8385
8386 /* If the section is 4-byte aligned, do not add fill. */
8387 if (sec->alignment_power > 2)
8388 {
8389 int fill_extra_space;
8390 bfd_vma entry_sec_offset;
8391 text_action *fa;
8392 property_table_entry *the_add_entry;
8393 int removed_diff;
8394
8395 if (entry)
8396 entry_sec_offset = entry->address - sec->vma + entry->size;
8397 else
8398 entry_sec_offset = rel->r_rel.target_offset + 4;
8399
8400 /* If the literal range is at the end of the section,
8401 do not add fill. */
8402 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8403 entry_sec_offset);
8404 fill_extra_space = compute_fill_extra_space (the_add_entry);
8405
8406 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8407 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8408 -4, fill_extra_space);
8409 if (fa)
8410 adjust_fill_action (fa, removed_diff);
8411 else
8412 text_action_add (&relax_info->action_list,
8413 ta_fill, sec, entry_sec_offset, removed_diff);
8414 }
8415
8416 /* Zero out the relocation on this literal location. */
8417 if (irel)
8418 {
8419 if (elf_hash_table (link_info)->dynamic_sections_created)
8420 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8421
8422 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8423 pin_internal_relocs (sec, internal_relocs);
8424 }
8425
8426 /* Do not modify "last_loc_is_prev". */
8427 return TRUE;
8428}
8429
8430
8431bfd_boolean
7fa3d080
BW		 8432identify_literal_placement (bfd *abfd,
8433 asection *sec,
8434 bfd_byte *contents,
8435 struct bfd_link_info *link_info,
8436 value_map_hash_table *values,
8437 bfd_boolean *last_loc_is_prev_p,
8438 Elf_Internal_Rela *irel,
8439 int remaining_src_rels,
8440 source_reloc *rel,
8441 property_table_entry *prop_table,
8442 int ptblsize,
8443 section_cache_t *target_sec_cache,
8444 bfd_boolean is_abs_literal)
43cd72b9
BW		 8445{
8446 literal_value val;
8447 value_map *val_map;
8448 xtensa_relax_info *relax_info;
8449 bfd_boolean literal_placed = FALSE;
8450 r_reloc r_rel;
8451 unsigned long value;
8452 bfd_boolean final_static_link;
8453 bfd_size_type sec_size;
8454
8455 relax_info = get_xtensa_relax_info (sec);
8456 if (!relax_info)
8457 return FALSE;
8458
8459 sec_size = bfd_get_section_limit (abfd, sec);
8460
8461 final_static_link =
8462 (!link_info->relocatable
8463 && !elf_hash_table (link_info)->dynamic_sections_created);
8464
8465 /* The placement algorithm first checks to see if the literal is
8466 already in the value map. If so and the value map is reachable
8467 from all uses, then the literal is moved to that location. If
8468 not, then we identify the last location where a fresh literal was
8469 placed. If the literal can be safely moved there, then we do so.
8470 If not, then we assume that the literal is not to move and leave
8471 the literal where it is, marking it as the last literal
8472 location. */
8473
8474 /* Find the literal value. */
8475 value = 0;
8476 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8477 if (!irel)
8478 {
8479 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8480 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8481 }
8482 init_literal_value (&val, &r_rel, value, is_abs_literal);
8483
8484 /* Check if we've seen another literal with the same value that
8485 is in the same output section. */
8486 val_map = value_map_get_cached_value (values, &val, final_static_link);
8487
8488 if (val_map
8489 && (r_reloc_get_section (&val_map->loc)->output_section
8490 == sec->output_section)
8491 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8492 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8493 {
8494 /* No change to last_loc_is_prev. */
8495 literal_placed = TRUE;
8496 }
8497
8498 /* For relocatable links, do not try to move literals. To do it
8499 correctly might increase the number of relocations in an input
8500 section making the default relocatable linking fail. */
8501 if (!link_info->relocatable && !literal_placed
8502 && values->has_last_loc && !(*last_loc_is_prev_p))
8503 {
8504 asection *target_sec = r_reloc_get_section (&values->last_loc);
8505 if (target_sec && target_sec->output_section == sec->output_section)
8506 {
8507 /* Increment the virtual offset. */
8508 r_reloc try_loc = values->last_loc;
8509 try_loc.virtual_offset += 4;
8510
8511 /* There is a last loc that was in the same output section. */
8512 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8513 && move_shared_literal (sec, link_info, rel,
8514 prop_table, ptblsize,
8515 &try_loc, &val, target_sec_cache))
e0001a05 8516 {
43cd72b9
BW		 8517 values->last_loc.virtual_offset += 4;
8518 literal_placed = TRUE;
8519 if (!val_map)
8520 val_map = add_value_map (values, &val, &try_loc,
8521 final_static_link);
8522 else
8523 val_map->loc = try_loc;
e0001a05
NC		 8524 }
8525 }
43cd72b9
BW		 8526 }
8527
8528 if (!literal_placed)
8529 {
8530 /* Nothing worked, leave the literal alone but update the last loc. */
8531 values->has_last_loc = TRUE;
8532 values->last_loc = rel->r_rel;
8533 if (!val_map)
8534 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
e0001a05 8535 else
43cd72b9
BW		 8536 val_map->loc = rel->r_rel;
8537 *last_loc_is_prev_p = TRUE;
e0001a05
NC		 8538 }
8539
43cd72b9 8540 return TRUE;
e0001a05
NC		 8541}
8542
8543
8544/* Check if the original relocations (presumably on L32R instructions)
8545 identified by reloc[0..N] can be changed to reference the literal
8546 identified by r_rel. If r_rel is out of range for any of the
8547 original relocations, then we don't want to coalesce the original
8548 literal with the one at r_rel. We only check reloc[0..N], where the
8549 offsets are all the same as for reloc[0] (i.e., they're all
8550 referencing the same literal) and where N is also bounded by the
8551 number of remaining entries in the "reloc" array. The "reloc" array
8552 is sorted by target offset so we know all the entries for the same
8553 literal will be contiguous. */
8554
8555static bfd_boolean
7fa3d080
BW		 8556relocations_reach (source_reloc *reloc,
8557 int remaining_relocs,
8558 const r_reloc *r_rel)
e0001a05
NC		 8559{
8560 bfd_vma from_offset, source_address, dest_address;
8561 asection *sec;
8562 int i;
8563
8564 if (!r_reloc_is_defined (r_rel))
8565 return FALSE;
8566
8567 sec = r_reloc_get_section (r_rel);
8568 from_offset = reloc[0].r_rel.target_offset;
8569
8570 for (i = 0; i < remaining_relocs; i++)
8571 {
8572 if (reloc[i].r_rel.target_offset != from_offset)
8573 break;
8574
8575 /* Ignore relocations that have been removed. */
8576 if (reloc[i].is_null)
8577 continue;
8578
8579 /* The original and new output section for these must be the same
8580 in order to coalesce. */
8581 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8582 != sec->output_section)
8583 return FALSE;
8584
d638e0ac
BW		 8585 /* Absolute literals in the same output section can always be
8586 combined. */
8587 if (reloc[i].is_abs_literal)
8588 continue;
8589
43cd72b9
BW		 8590 /* A literal with no PC-relative relocations can be moved anywhere. */
8591 if (reloc[i].opnd != -1)
e0001a05
NC		 8592 {
8593 /* Otherwise, check to see that it fits. */
8594 source_address = (reloc[i].source_sec->output_section->vma
8595 + reloc[i].source_sec->output_offset
8596 + reloc[i].r_rel.rela.r_offset);
8597 dest_address = (sec->output_section->vma
8598 + sec->output_offset
8599 + r_rel->target_offset);
8600
43cd72b9
BW		 8601 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8602 source_address, dest_address))
e0001a05
NC		 8603 return FALSE;
8604 }
8605 }
8606
8607 return TRUE;
8608}
8609
8610
43cd72b9
BW		 8611/* Move a literal to another literal location because it is
8612 the same as the other literal value. */
e0001a05 8613
43cd72b9 8614static bfd_boolean
7fa3d080
BW		 8615coalesce_shared_literal (asection *sec,
8616 source_reloc *rel,
8617 property_table_entry *prop_table,
8618 int ptblsize,
8619 value_map *val_map)
e0001a05 8620{
43cd72b9
BW		 8621 property_table_entry *entry;
8622 text_action *fa;
8623 property_table_entry *the_add_entry;
8624 int removed_diff;
8625 xtensa_relax_info *relax_info;
8626
8627 relax_info = get_xtensa_relax_info (sec);
8628 if (!relax_info)
8629 return FALSE;
8630
8631 entry = elf_xtensa_find_property_entry
8632 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
99ded152 8633 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
43cd72b9
BW		 8634 return TRUE;
8635
8636 /* Mark that the literal will be coalesced. */
8637 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8638
8639 text_action_add (&relax_info->action_list,
8640 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8641
8642 /* If the section is 4-byte aligned, do not add fill. */
8643 if (sec->alignment_power > 2)
e0001a05 8644 {
43cd72b9
BW		 8645 int fill_extra_space;
8646 bfd_vma entry_sec_offset;
8647
8648 if (entry)
8649 entry_sec_offset = entry->address - sec->vma + entry->size;
8650 else
8651 entry_sec_offset = rel->r_rel.target_offset + 4;
8652
8653 /* If the literal range is at the end of the section,
8654 do not add fill. */
8655 fill_extra_space = 0;
8656 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8657 entry_sec_offset);
8658 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8659 fill_extra_space = the_add_entry->size;
8660
8661 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8662 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8663 -4, fill_extra_space);
8664 if (fa)
8665 adjust_fill_action (fa, removed_diff);
8666 else
8667 text_action_add (&relax_info->action_list,
8668 ta_fill, sec, entry_sec_offset, removed_diff);
e0001a05 8669 }
43cd72b9
BW		 8670
8671 return TRUE;
8672}
8673
8674
8675/* Move a literal to another location. This may actually increase the
8676 total amount of space used because of alignments so we need to do
8677 this carefully. Also, it may make a branch go out of range. */
8678
8679static bfd_boolean
7fa3d080
BW		 8680move_shared_literal (asection *sec,
8681 struct bfd_link_info *link_info,
8682 source_reloc *rel,
8683 property_table_entry *prop_table,
8684 int ptblsize,
8685 const r_reloc *target_loc,
8686 const literal_value *lit_value,
8687 section_cache_t *target_sec_cache)
43cd72b9
BW		 8688{
8689 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8690 text_action *fa, *target_fa;
8691 int removed_diff;
8692 xtensa_relax_info *relax_info, *target_relax_info;
8693 asection *target_sec;
8694 ebb_t *ebb;
8695 ebb_constraint ebb_table;
8696 bfd_boolean relocs_fit;
8697
8698 /* If this routine always returns FALSE, the literals that cannot be
8699 coalesced will not be moved. */
8700 if (elf32xtensa_no_literal_movement)
8701 return FALSE;
8702
8703 relax_info = get_xtensa_relax_info (sec);
8704 if (!relax_info)
8705 return FALSE;
8706
8707 target_sec = r_reloc_get_section (target_loc);
8708 target_relax_info = get_xtensa_relax_info (target_sec);
8709
8710 /* Literals to undefined sections may not be moved because they
8711 must report an error. */
8712 if (bfd_is_und_section (target_sec))
8713 return FALSE;
8714
8715 src_entry = elf_xtensa_find_property_entry
8716 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8717
8718 if (!section_cache_section (target_sec_cache, target_sec, link_info))
8719 return FALSE;
8720
8721 target_entry = elf_xtensa_find_property_entry
8722 (target_sec_cache->ptbl, target_sec_cache->pte_count,
8723 target_sec->vma + target_loc->target_offset);
8724
8725 if (!target_entry)
8726 return FALSE;
8727
8728 /* Make sure that we have not broken any branches. */
8729 relocs_fit = FALSE;
8730
8731 init_ebb_constraint (&ebb_table);
8732 ebb = &ebb_table.ebb;
8733 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8734 target_sec_cache->content_length,
8735 target_sec_cache->ptbl, target_sec_cache->pte_count,
8736 target_sec_cache->relocs, target_sec_cache->reloc_count);
8737
8738 /* Propose to add 4 bytes + worst-case alignment size increase to
8739 destination. */
8740 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8741 ta_fill, target_loc->target_offset,
8742 -4 - (1 << target_sec->alignment_power), TRUE);
8743
8744 /* Check all of the PC-relative relocations to make sure they still fit. */
8745 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8746 target_sec_cache->contents,
8747 target_sec_cache->relocs,
cb337148 8748 &ebb_table, NULL);
43cd72b9
BW		 8749
8750 if (!relocs_fit)
8751 return FALSE;
8752
8753 text_action_add_literal (&target_relax_info->action_list,
8754 ta_add_literal, target_loc, lit_value, -4);
8755
8756 if (target_sec->alignment_power > 2 && target_entry != src_entry)
8757 {
8758 /* May need to add or remove some fill to maintain alignment. */
8759 int fill_extra_space;
8760 bfd_vma entry_sec_offset;
8761
8762 entry_sec_offset =
8763 target_entry->address - target_sec->vma + target_entry->size;
8764
8765 /* If the literal range is at the end of the section,
8766 do not add fill. */
8767 fill_extra_space = 0;
8768 the_add_entry =
8769 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8770 target_sec_cache->pte_count,
8771 entry_sec_offset);
8772 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8773 fill_extra_space = the_add_entry->size;
8774
8775 target_fa = find_fill_action (&target_relax_info->action_list,
8776 target_sec, entry_sec_offset);
8777 removed_diff = compute_removed_action_diff (target_fa, target_sec,
8778 entry_sec_offset, 4,
8779 fill_extra_space);
8780 if (target_fa)
8781 adjust_fill_action (target_fa, removed_diff);
8782 else
8783 text_action_add (&target_relax_info->action_list,
8784 ta_fill, target_sec, entry_sec_offset, removed_diff);
8785 }
8786
8787 /* Mark that the literal will be moved to the new location. */
8788 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8789
8790 /* Remove the literal. */
8791 text_action_add (&relax_info->action_list,
8792 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8793
8794 /* If the section is 4-byte aligned, do not add fill. */
8795 if (sec->alignment_power > 2 && target_entry != src_entry)
8796 {
8797 int fill_extra_space;
8798 bfd_vma entry_sec_offset;
8799
8800 if (src_entry)
8801 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8802 else
8803 entry_sec_offset = rel->r_rel.target_offset+4;
8804
8805 /* If the literal range is at the end of the section,
8806 do not add fill. */
8807 fill_extra_space = 0;
8808 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8809 entry_sec_offset);
8810 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8811 fill_extra_space = the_add_entry->size;
8812
8813 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8814 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8815 -4, fill_extra_space);
8816 if (fa)
8817 adjust_fill_action (fa, removed_diff);
8818 else
8819 text_action_add (&relax_info->action_list,
8820 ta_fill, sec, entry_sec_offset, removed_diff);
8821 }
8822
8823 return TRUE;
e0001a05
NC		 8824}
8825
8826\f
8827/* Second relaxation pass. */
8828
8829/* Modify all of the relocations to point to the right spot, and if this
8830 is a relaxable section, delete the unwanted literals and fix the
43cd72b9 8831 section size. */
e0001a05 8832
43cd72b9 8833bfd_boolean
7fa3d080 8834relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
e0001a05
NC		 8835{
8836 Elf_Internal_Rela *internal_relocs;
8837 xtensa_relax_info *relax_info;
8838 bfd_byte *contents;
8839 bfd_boolean ok = TRUE;
8840 unsigned i;
43cd72b9
BW		 8841 bfd_boolean rv = FALSE;
8842 bfd_boolean virtual_action;
8843 bfd_size_type sec_size;
e0001a05 8844
43cd72b9 8845 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 8846 relax_info = get_xtensa_relax_info (sec);
8847 BFD_ASSERT (relax_info);
8848
43cd72b9
BW		 8849 /* First translate any of the fixes that have been added already. */
8850 translate_section_fixes (sec);
8851
e0001a05
NC		 8852 /* Handle property sections (e.g., literal tables) specially. */
8853 if (xtensa_is_property_section (sec))
8854 {
8855 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8856 return relax_property_section (abfd, sec, link_info);
8857 }
8858
43cd72b9
BW		 8859 internal_relocs = retrieve_internal_relocs (abfd, sec,
8860 link_info->keep_memory);
7aa09196
SA		 8861 if (!internal_relocs && !relax_info->action_list.head)
8862 return TRUE;
8863
43cd72b9
BW		 8864 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8865 if (contents == NULL && sec_size != 0)
8866 {
8867 ok = FALSE;
8868 goto error_return;
8869 }
8870
8871 if (internal_relocs)
8872 {
8873 for (i = 0; i < sec->reloc_count; i++)
8874 {
8875 Elf_Internal_Rela *irel;
8876 xtensa_relax_info *target_relax_info;
8877 bfd_vma source_offset, old_source_offset;
8878 r_reloc r_rel;
8879 unsigned r_type;
8880 asection *target_sec;
8881
8882 /* Locally change the source address.
8883 Translate the target to the new target address.
8884 If it points to this section and has been removed,
8885 NULLify it.
8886 Write it back. */
8887
8888 irel = &internal_relocs[i];
8889 source_offset = irel->r_offset;
8890 old_source_offset = source_offset;
8891
8892 r_type = ELF32_R_TYPE (irel->r_info);
8893 r_reloc_init (&r_rel, abfd, irel, contents,
8894 bfd_get_section_limit (abfd, sec));
8895
8896 /* If this section could have changed then we may need to
8897 change the relocation's offset. */
8898
8899 if (relax_info->is_relaxable_literal_section
8900 || relax_info->is_relaxable_asm_section)
8901 {
9b7f5d20
BW		 8902 pin_internal_relocs (sec, internal_relocs);
8903
43cd72b9
BW		 8904 if (r_type != R_XTENSA_NONE
8905 && find_removed_literal (&relax_info->removed_list,
8906 irel->r_offset))
8907 {
8908 /* Remove this relocation. */
8909 if (elf_hash_table (link_info)->dynamic_sections_created)
8910 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8911 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8912 irel->r_offset = offset_with_removed_text
8913 (&relax_info->action_list, irel->r_offset);
43cd72b9
BW		 8914 continue;
8915 }
8916
8917 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8918 {
8919 text_action *action =
8920 find_insn_action (&relax_info->action_list,
8921 irel->r_offset);
8922 if (action && (action->action == ta_convert_longcall
8923 || action->action == ta_remove_longcall))
8924 {
8925 bfd_reloc_status_type retval;
8926 char *error_message = NULL;
8927
8928 retval = contract_asm_expansion (contents, sec_size,
8929 irel, &error_message);
8930 if (retval != bfd_reloc_ok)
8931 {
8932 (*link_info->callbacks->reloc_dangerous)
8933 (link_info, error_message, abfd, sec,
8934 irel->r_offset);
8935 goto error_return;
8936 }
8937 /* Update the action so that the code that moves
8938 the contents will do the right thing. */
8939 if (action->action == ta_remove_longcall)
8940 action->action = ta_remove_insn;
8941 else
8942 action->action = ta_none;
8943 /* Refresh the info in the r_rel. */
8944 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8945 r_type = ELF32_R_TYPE (irel->r_info);
8946 }
8947 }
8948
8949 source_offset = offset_with_removed_text
8950 (&relax_info->action_list, irel->r_offset);
8951 irel->r_offset = source_offset;
8952 }
8953
8954 /* If the target section could have changed then
8955 we may need to change the relocation's target offset. */
8956
8957 target_sec = r_reloc_get_section (&r_rel);
43cd72b9 8958
ae326da8
BW		 8959 /* For a reference to a discarded section from a DWARF section,
8960 i.e., where action_discarded is PRETEND, the symbol will
8961 eventually be modified to refer to the kept section (at least if
8962 the kept and discarded sections are the same size). Anticipate
8963 that here and adjust things accordingly. */
8964 if (! elf_xtensa_ignore_discarded_relocs (sec)
8965 && elf_xtensa_action_discarded (sec) == PRETEND
dbaa2011 8966 && sec->sec_info_type != SEC_INFO_TYPE_STABS
ae326da8 8967 && target_sec != NULL
dbaa2011 8968 && discarded_section (target_sec))
ae326da8
BW		 8969 {
8970 /* It would be natural to call _bfd_elf_check_kept_section
8971 here, but it's not exported from elflink.c. It's also a
8972 fairly expensive check. Adjusting the relocations to the
8973 discarded section is fairly harmless; it will only adjust
8974 some addends and difference values. If it turns out that
8975 _bfd_elf_check_kept_section fails later, it won't matter,
8976 so just compare the section names to find the right group
8977 member. */
8978 asection *kept = target_sec->kept_section;
8979 if (kept != NULL)
8980 {
8981 if ((kept->flags & SEC_GROUP) != 0)
8982 {
8983 asection *first = elf_next_in_group (kept);
8984 asection *s = first;
8985
8986 kept = NULL;
8987 while (s != NULL)
8988 {
8989 if (strcmp (s->name, target_sec->name) == 0)
8990 {
8991 kept = s;
8992 break;
8993 }
8994 s = elf_next_in_group (s);
8995 if (s == first)
8996 break;
8997 }
8998 }
8999 }
9000 if (kept != NULL
9001 && ((target_sec->rawsize != 0
9002 ? target_sec->rawsize : target_sec->size)
9003 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9004 target_sec = kept;
9005 }
9006
9007 target_relax_info = get_xtensa_relax_info (target_sec);
43cd72b9
BW		 9008 if (target_relax_info
9009 && (target_relax_info->is_relaxable_literal_section
9010 || target_relax_info->is_relaxable_asm_section))
9011 {
9012 r_reloc new_reloc;
9b7f5d20 9013 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
43cd72b9
BW		 9014
9015 if (r_type == R_XTENSA_DIFF8
9016 || r_type == R_XTENSA_DIFF16
9017 || r_type == R_XTENSA_DIFF32)
9018 {
9019 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
9020
9021 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9022 {
9023 (*link_info->callbacks->reloc_dangerous)
9024 (link_info, _("invalid relocation address"),
9025 abfd, sec, old_source_offset);
9026 goto error_return;
9027 }
9028
9029 switch (r_type)
9030 {
9031 case R_XTENSA_DIFF8:
9032 diff_value =
9033 bfd_get_8 (abfd, &contents[old_source_offset]);
9034 break;
9035 case R_XTENSA_DIFF16:
9036 diff_value =
9037 bfd_get_16 (abfd, &contents[old_source_offset]);
9038 break;
9039 case R_XTENSA_DIFF32:
9040 diff_value =
9041 bfd_get_32 (abfd, &contents[old_source_offset]);
9042 break;
9043 }
9044
9045 new_end_offset = offset_with_removed_text
9046 (&target_relax_info->action_list,
9047 r_rel.target_offset + diff_value);
9048 diff_value = new_end_offset - new_reloc.target_offset;
9049
9050 switch (r_type)
9051 {
9052 case R_XTENSA_DIFF8:
9053 diff_mask = 0xff;
9054 bfd_put_8 (abfd, diff_value,
9055 &contents[old_source_offset]);
9056 break;
9057 case R_XTENSA_DIFF16:
9058 diff_mask = 0xffff;
9059 bfd_put_16 (abfd, diff_value,
9060 &contents[old_source_offset]);
9061 break;
9062 case R_XTENSA_DIFF32:
9063 diff_mask = 0xffffffff;
9064 bfd_put_32 (abfd, diff_value,
9065 &contents[old_source_offset]);
9066 break;
9067 }
9068
9069 /* Check for overflow. */
9070 if ((diff_value & ~diff_mask) != 0)
9071 {
9072 (*link_info->callbacks->reloc_dangerous)
9073 (link_info, _("overflow after relaxation"),
9074 abfd, sec, old_source_offset);
9075 goto error_return;
9076 }
9077
9078 pin_contents (sec, contents);
9079 }
dc96b90a
BW		 9080
9081 /* If the relocation still references a section in the same
9082 input file, modify the relocation directly instead of
9083 adding a "fix" record. */
9084 if (target_sec->owner == abfd)
9085 {
9086 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9087 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9088 irel->r_addend = new_reloc.rela.r_addend;
9089 pin_internal_relocs (sec, internal_relocs);
9090 }
9b7f5d20
BW		 9091 else
9092 {
dc96b90a
BW		 9093 bfd_vma addend_displacement;
9094 reloc_bfd_fix *fix;
9095
9096 addend_displacement =
9097 new_reloc.target_offset + new_reloc.virtual_offset;
9098 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9099 target_sec,
9100 addend_displacement, TRUE);
9101 add_fix (sec, fix);
9b7f5d20 9102 }
43cd72b9 9103 }
43cd72b9
BW		 9104 }
9105 }
9106
9107 if ((relax_info->is_relaxable_literal_section
9108 || relax_info->is_relaxable_asm_section)
9109 && relax_info->action_list.head)
9110 {
9111 /* Walk through the planned actions and build up a table
9112 of move, copy and fill records. Use the move, copy and
9113 fill records to perform the actions once. */
9114
43cd72b9
BW		 9115 int removed = 0;
9116 bfd_size_type final_size, copy_size, orig_insn_size;
9117 bfd_byte *scratch = NULL;
9118 bfd_byte *dup_contents = NULL;
a3ef2d63 9119 bfd_size_type orig_size = sec->size;
43cd72b9
BW		 9120 bfd_vma orig_dot = 0;
9121 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9122 orig dot in physical memory. */
9123 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9124 bfd_vma dup_dot = 0;
9125
9126 text_action *action = relax_info->action_list.head;
9127
9128 final_size = sec->size;
9129 for (action = relax_info->action_list.head; action;
9130 action = action->next)
9131 {
9132 final_size -= action->removed_bytes;
9133 }
9134
9135 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9136 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9137
9138 /* The dot is the current fill location. */
9139#if DEBUG
9140 print_action_list (stderr, &relax_info->action_list);
9141#endif
9142
9143 for (action = relax_info->action_list.head; action;
9144 action = action->next)
9145 {
9146 virtual_action = FALSE;
9147 if (action->offset > orig_dot)
9148 {
9149 orig_dot += orig_dot_copied;
9150 orig_dot_copied = 0;
9151 orig_dot_vo = 0;
9152 /* Out of the virtual world. */
9153 }
9154
9155 if (action->offset > orig_dot)
9156 {
9157 copy_size = action->offset - orig_dot;
9158 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9159 orig_dot += copy_size;
9160 dup_dot += copy_size;
9161 BFD_ASSERT (action->offset == orig_dot);
9162 }
9163 else if (action->offset < orig_dot)
9164 {
9165 if (action->action == ta_fill
9166 && action->offset - action->removed_bytes == orig_dot)
9167 {
9168 /* This is OK because the fill only effects the dup_dot. */
9169 }
9170 else if (action->action == ta_add_literal)
9171 {
9172 /* TBD. Might need to handle this. */
9173 }
9174 }
9175 if (action->offset == orig_dot)
9176 {
9177 if (action->virtual_offset > orig_dot_vo)
9178 {
9179 if (orig_dot_vo == 0)
9180 {
9181 /* Need to copy virtual_offset bytes. Probably four. */
9182 copy_size = action->virtual_offset - orig_dot_vo;
9183 memmove (&dup_contents[dup_dot],
9184 &contents[orig_dot], copy_size);
9185 orig_dot_copied = copy_size;
9186 dup_dot += copy_size;
9187 }
9188 virtual_action = TRUE;
9189 }
9190 else
9191 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9192 }
9193 switch (action->action)
9194 {
9195 case ta_remove_literal:
9196 case ta_remove_insn:
9197 BFD_ASSERT (action->removed_bytes >= 0);
9198 orig_dot += action->removed_bytes;
9199 break;
9200
9201 case ta_narrow_insn:
9202 orig_insn_size = 3;
9203 copy_size = 2;
9204 memmove (scratch, &contents[orig_dot], orig_insn_size);
9205 BFD_ASSERT (action->removed_bytes == 1);
64b607e6 9206 rv = narrow_instruction (scratch, final_size, 0);
43cd72b9
BW		 9207 BFD_ASSERT (rv);
9208 memmove (&dup_contents[dup_dot], scratch, copy_size);
9209 orig_dot += orig_insn_size;
9210 dup_dot += copy_size;
9211 break;
9212
9213 case ta_fill:
9214 if (action->removed_bytes >= 0)
9215 orig_dot += action->removed_bytes;
9216 else
9217 {
9218 /* Already zeroed in dup_contents. Just bump the
9219 counters. */
9220 dup_dot += (-action->removed_bytes);
9221 }
9222 break;
9223
9224 case ta_none:
9225 BFD_ASSERT (action->removed_bytes == 0);
9226 break;
9227
9228 case ta_convert_longcall:
9229 case ta_remove_longcall:
9230 /* These will be removed or converted before we get here. */
9231 BFD_ASSERT (0);
9232 break;
9233
9234 case ta_widen_insn:
9235 orig_insn_size = 2;
9236 copy_size = 3;
9237 memmove (scratch, &contents[orig_dot], orig_insn_size);
9238 BFD_ASSERT (action->removed_bytes == -1);
64b607e6 9239 rv = widen_instruction (scratch, final_size, 0);
43cd72b9
BW		 9240 BFD_ASSERT (rv);
9241 memmove (&dup_contents[dup_dot], scratch, copy_size);
9242 orig_dot += orig_insn_size;
9243 dup_dot += copy_size;
9244 break;
9245
9246 case ta_add_literal:
9247 orig_insn_size = 0;
9248 copy_size = 4;
9249 BFD_ASSERT (action->removed_bytes == -4);
9250 /* TBD -- place the literal value here and insert
9251 into the table. */
9252 memset (&dup_contents[dup_dot], 0, 4);
9253 pin_internal_relocs (sec, internal_relocs);
9254 pin_contents (sec, contents);
9255
9256 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9257 relax_info, &internal_relocs, &action->value))
9258 goto error_return;
9259
9260 if (virtual_action)
9261 orig_dot_vo += copy_size;
9262
9263 orig_dot += orig_insn_size;
9264 dup_dot += copy_size;
9265 break;
9266
9267 default:
9268 /* Not implemented yet. */
9269 BFD_ASSERT (0);
9270 break;
9271 }
9272
43cd72b9
BW		 9273 removed += action->removed_bytes;
9274 BFD_ASSERT (dup_dot <= final_size);
9275 BFD_ASSERT (orig_dot <= orig_size);
9276 }
9277
9278 orig_dot += orig_dot_copied;
9279 orig_dot_copied = 0;
9280
9281 if (orig_dot != orig_size)
9282 {
9283 copy_size = orig_size - orig_dot;
9284 BFD_ASSERT (orig_size > orig_dot);
9285 BFD_ASSERT (dup_dot + copy_size == final_size);
9286 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9287 orig_dot += copy_size;
9288 dup_dot += copy_size;
9289 }
9290 BFD_ASSERT (orig_size == orig_dot);
9291 BFD_ASSERT (final_size == dup_dot);
9292
9293 /* Move the dup_contents back. */
9294 if (final_size > orig_size)
9295 {
9296 /* Contents need to be reallocated. Swap the dup_contents into
9297 contents. */
9298 sec->contents = dup_contents;
9299 free (contents);
9300 contents = dup_contents;
9301 pin_contents (sec, contents);
9302 }
9303 else
9304 {
9305 BFD_ASSERT (final_size <= orig_size);
9306 memset (contents, 0, orig_size);
9307 memcpy (contents, dup_contents, final_size);
9308 free (dup_contents);
9309 }
9310 free (scratch);
9311 pin_contents (sec, contents);
9312
a3ef2d63
BW		 9313 if (sec->rawsize == 0)
9314 sec->rawsize = sec->size;
43cd72b9
BW		 9315 sec->size = final_size;
9316 }
9317
9318 error_return:
9319 release_internal_relocs (sec, internal_relocs);
9320 release_contents (sec, contents);
9321 return ok;
9322}
9323
9324
9325static bfd_boolean
7fa3d080 9326translate_section_fixes (asection *sec)
43cd72b9
BW		 9327{
9328 xtensa_relax_info *relax_info;
9329 reloc_bfd_fix *r;
9330
9331 relax_info = get_xtensa_relax_info (sec);
9332 if (!relax_info)
9333 return TRUE;
9334
9335 for (r = relax_info->fix_list; r != NULL; r = r->next)
9336 if (!translate_reloc_bfd_fix (r))
9337 return FALSE;
e0001a05 9338
43cd72b9
BW		 9339 return TRUE;
9340}
e0001a05 9341
e0001a05 9342
43cd72b9
BW		 9343/* Translate a fix given the mapping in the relax info for the target
9344 section. If it has already been translated, no work is required. */
e0001a05 9345
43cd72b9 9346static bfd_boolean
7fa3d080 9347translate_reloc_bfd_fix (reloc_bfd_fix *fix)
43cd72b9
BW		 9348{
9349 reloc_bfd_fix new_fix;
9350 asection *sec;
9351 xtensa_relax_info *relax_info;
9352 removed_literal *removed;
9353 bfd_vma new_offset, target_offset;
e0001a05 9354
43cd72b9
BW		 9355 if (fix->translated)
9356 return TRUE;
e0001a05 9357
43cd72b9
BW		 9358 sec = fix->target_sec;
9359 target_offset = fix->target_offset;
e0001a05 9360
43cd72b9
BW		 9361 relax_info = get_xtensa_relax_info (sec);
9362 if (!relax_info)
9363 {
9364 fix->translated = TRUE;
9365 return TRUE;
9366 }
e0001a05 9367
43cd72b9 9368 new_fix = *fix;
e0001a05 9369
43cd72b9
BW		 9370 /* The fix does not need to be translated if the section cannot change. */
9371 if (!relax_info->is_relaxable_literal_section
9372 && !relax_info->is_relaxable_asm_section)
9373 {
9374 fix->translated = TRUE;
9375 return TRUE;
9376 }
e0001a05 9377
43cd72b9
BW		 9378 /* If the literal has been moved and this relocation was on an
9379 opcode, then the relocation should move to the new literal
9380 location. Otherwise, the relocation should move within the
9381 section. */
9382
9383 removed = FALSE;
9384 if (is_operand_relocation (fix->src_type))
9385 {
9386 /* Check if the original relocation is against a literal being
9387 removed. */
9388 removed = find_removed_literal (&relax_info->removed_list,
9389 target_offset);
e0001a05
NC		 9390 }
9391
43cd72b9 9392 if (removed)
e0001a05 9393 {
43cd72b9 9394 asection *new_sec;
e0001a05 9395
43cd72b9
BW		 9396 /* The fact that there is still a relocation to this literal indicates
9397 that the literal is being coalesced, not simply removed. */
9398 BFD_ASSERT (removed->to.abfd != NULL);
e0001a05 9399
43cd72b9
BW		 9400 /* This was moved to some other address (possibly another section). */
9401 new_sec = r_reloc_get_section (&removed->to);
9402 if (new_sec != sec)
e0001a05 9403 {
43cd72b9
BW		 9404 sec = new_sec;
9405 relax_info = get_xtensa_relax_info (sec);
9406 if (!relax_info ||
9407 (!relax_info->is_relaxable_literal_section
9408 && !relax_info->is_relaxable_asm_section))
e0001a05 9409 {
43cd72b9
BW		 9410 target_offset = removed->to.target_offset;
9411 new_fix.target_sec = new_sec;
9412 new_fix.target_offset = target_offset;
9413 new_fix.translated = TRUE;
9414 *fix = new_fix;
9415 return TRUE;
e0001a05 9416 }
e0001a05 9417 }
43cd72b9
BW		 9418 target_offset = removed->to.target_offset;
9419 new_fix.target_sec = new_sec;
e0001a05 9420 }
43cd72b9
BW		 9421
9422 /* The target address may have been moved within its section. */
9423 new_offset = offset_with_removed_text (&relax_info->action_list,
9424 target_offset);
9425
9426 new_fix.target_offset = new_offset;
9427 new_fix.target_offset = new_offset;
9428 new_fix.translated = TRUE;
9429 *fix = new_fix;
9430 return TRUE;
e0001a05
NC		 9431}
9432
9433
9434/* Fix up a relocation to take account of removed literals. */
9435
9b7f5d20
BW		 9436static asection *
9437translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
e0001a05 9438{
e0001a05
NC		 9439 xtensa_relax_info *relax_info;
9440 removed_literal *removed;
9b7f5d20
BW		 9441 bfd_vma target_offset, base_offset;
9442 text_action *act;
e0001a05
NC		 9443
9444 *new_rel = *orig_rel;
9445
9446 if (!r_reloc_is_defined (orig_rel))
9b7f5d20 9447 return sec ;
e0001a05
NC		 9448
9449 relax_info = get_xtensa_relax_info (sec);
9b7f5d20
BW		 9450 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9451 || relax_info->is_relaxable_asm_section));
e0001a05 9452
43cd72b9
BW		 9453 target_offset = orig_rel->target_offset;
9454
9455 removed = FALSE;
9456 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9457 {
9458 /* Check if the original relocation is against a literal being
9459 removed. */
9460 removed = find_removed_literal (&relax_info->removed_list,
9461 target_offset);
9462 }
9463 if (removed && removed->to.abfd)
e0001a05
NC		 9464 {
9465 asection *new_sec;
9466
9467 /* The fact that there is still a relocation to this literal indicates
9468 that the literal is being coalesced, not simply removed. */
9469 BFD_ASSERT (removed->to.abfd != NULL);
9470
43cd72b9
BW		 9471 /* This was moved to some other address
9472 (possibly in another section). */
e0001a05
NC		 9473 *new_rel = removed->to;
9474 new_sec = r_reloc_get_section (new_rel);
43cd72b9 9475 if (new_sec != sec)
e0001a05
NC		 9476 {
9477 sec = new_sec;
9478 relax_info = get_xtensa_relax_info (sec);
43cd72b9
BW		 9479 if (!relax_info
9480 || (!relax_info->is_relaxable_literal_section
9481 && !relax_info->is_relaxable_asm_section))
9b7f5d20 9482 return sec;
e0001a05 9483 }
43cd72b9 9484 target_offset = new_rel->target_offset;
e0001a05
NC		 9485 }
9486
9b7f5d20
BW		 9487 /* Find the base offset of the reloc symbol, excluding any addend from the
9488 reloc or from the section contents (for a partial_inplace reloc). Then
9489 find the adjusted values of the offsets due to relaxation. The base
9490 offset is needed to determine the change to the reloc's addend; the reloc
9491 addend should not be adjusted due to relaxations located before the base
9492 offset. */
9493
9494 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9495 act = relax_info->action_list.head;
9496 if (base_offset <= target_offset)
9497 {
9498 int base_removed = removed_by_actions (&act, base_offset, FALSE);
9499 int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9500 new_rel->target_offset = target_offset - base_removed - addend_removed;
9501 new_rel->rela.r_addend -= addend_removed;
9502 }
9503 else
9504 {
9505 /* Handle a negative addend. The base offset comes first. */
9506 int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9507 int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9508 new_rel->target_offset = target_offset - tgt_removed;
9509 new_rel->rela.r_addend += addend_removed;
9510 }
e0001a05 9511
9b7f5d20 9512 return sec;
e0001a05
NC		 9513}
9514
9515
9516/* For dynamic links, there may be a dynamic relocation for each
9517 literal. The number of dynamic relocations must be computed in
9518 size_dynamic_sections, which occurs before relaxation. When a
9519 literal is removed, this function checks if there is a corresponding
9520 dynamic relocation and shrinks the size of the appropriate dynamic
9521 relocation section accordingly. At this point, the contents of the
9522 dynamic relocation sections have not yet been filled in, so there's
9523 nothing else that needs to be done. */
9524
9525static void
7fa3d080
BW		 9526shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9527 bfd *abfd,
9528 asection *input_section,
9529 Elf_Internal_Rela *rel)
e0001a05 9530{
f0e6fdb2 9531 struct elf_xtensa_link_hash_table *htab;
e0001a05
NC		 9532 Elf_Internal_Shdr *symtab_hdr;
9533 struct elf_link_hash_entry **sym_hashes;
9534 unsigned long r_symndx;
9535 int r_type;
9536 struct elf_link_hash_entry *h;
9537 bfd_boolean dynamic_symbol;
9538
f0e6fdb2 9539 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 9540 if (htab == NULL)
9541 return;
9542
e0001a05
NC		 9543 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9544 sym_hashes = elf_sym_hashes (abfd);
9545
9546 r_type = ELF32_R_TYPE (rel->r_info);
9547 r_symndx = ELF32_R_SYM (rel->r_info);
9548
9549 if (r_symndx < symtab_hdr->sh_info)
9550 h = NULL;
9551 else
9552 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9553
4608f3d9 9554 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
e0001a05
NC		 9555
9556 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9557 && (input_section->flags & SEC_ALLOC) != 0
9558 && (dynamic_symbol || info->shared))
9559 {
e0001a05
NC		 9560 asection *srel;
9561 bfd_boolean is_plt = FALSE;
9562
e0001a05
NC		 9563 if (dynamic_symbol && r_type == R_XTENSA_PLT)
9564 {
f0e6fdb2 9565 srel = htab->srelplt;
e0001a05
NC		 9566 is_plt = TRUE;
9567 }
9568 else
f0e6fdb2 9569 srel = htab->srelgot;
e0001a05
NC		 9570
9571 /* Reduce size of the .rela.* section by one reloc. */
e0001a05 9572 BFD_ASSERT (srel != NULL);
eea6121a
AM		 9573 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9574 srel->size -= sizeof (Elf32_External_Rela);
e0001a05
NC		 9575
9576 if (is_plt)
9577 {
9578 asection *splt, *sgotplt, *srelgot;
9579 int reloc_index, chunk;
9580
9581 /* Find the PLT reloc index of the entry being removed. This
9582 is computed from the size of ".rela.plt". It is needed to
9583 figure out which PLT chunk to resize. Usually "last index
9584 = size - 1" since the index starts at zero, but in this
9585 context, the size has just been decremented so there's no
9586 need to subtract one. */
eea6121a 9587 reloc_index = srel->size / sizeof (Elf32_External_Rela);
e0001a05
NC		 9588
9589 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
f0e6fdb2
BW		 9590 splt = elf_xtensa_get_plt_section (info, chunk);
9591 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
e0001a05
NC		 9592 BFD_ASSERT (splt != NULL && sgotplt != NULL);
9593
9594 /* Check if an entire PLT chunk has just been eliminated. */
9595 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9596 {
9597 /* The two magic GOT entries for that chunk can go away. */
f0e6fdb2 9598 srelgot = htab->srelgot;
e0001a05
NC		 9599 BFD_ASSERT (srelgot != NULL);
9600 srelgot->reloc_count -= 2;
eea6121a
AM		 9601 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9602 sgotplt->size -= 8;
e0001a05
NC		 9603
9604 /* There should be only one entry left (and it will be
9605 removed below). */
eea6121a
AM		 9606 BFD_ASSERT (sgotplt->size == 4);
9607 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
e0001a05
NC		 9608 }
9609
eea6121a
AM		 9610 BFD_ASSERT (sgotplt->size >= 4);
9611 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
e0001a05 9612
eea6121a
AM		 9613 sgotplt->size -= 4;
9614 splt->size -= PLT_ENTRY_SIZE;
e0001a05
NC		 9615 }
9616 }
9617}
9618
9619
43cd72b9
BW		 9620/* Take an r_rel and move it to another section. This usually
9621 requires extending the interal_relocation array and pinning it. If
9622 the original r_rel is from the same BFD, we can complete this here.
9623 Otherwise, we add a fix record to let the final link fix the
9624 appropriate address. Contents and internal relocations for the
9625 section must be pinned after calling this routine. */
9626
9627static bfd_boolean
7fa3d080
BW		 9628move_literal (bfd *abfd,
9629 struct bfd_link_info *link_info,
9630 asection *sec,
9631 bfd_vma offset,
9632 bfd_byte *contents,
9633 xtensa_relax_info *relax_info,
9634 Elf_Internal_Rela **internal_relocs_p,
9635 const literal_value *lit)
43cd72b9
BW		 9636{
9637 Elf_Internal_Rela *new_relocs = NULL;
9638 size_t new_relocs_count = 0;
9639 Elf_Internal_Rela this_rela;
9640 const r_reloc *r_rel;
9641
9642 r_rel = &lit->r_rel;
9643 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9644
9645 if (r_reloc_is_const (r_rel))
9646 bfd_put_32 (abfd, lit->value, contents + offset);
9647 else
9648 {
9649 int r_type;
9650 unsigned i;
43cd72b9
BW		 9651 reloc_bfd_fix *fix;
9652 unsigned insert_at;
9653
9654 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
43cd72b9
BW		 9655
9656 /* This is the difficult case. We have to create a fix up. */
9657 this_rela.r_offset = offset;
9658 this_rela.r_info = ELF32_R_INFO (0, r_type);
9659 this_rela.r_addend =
9660 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9661 bfd_put_32 (abfd, lit->value, contents + offset);
9662
9663 /* Currently, we cannot move relocations during a relocatable link. */
9664 BFD_ASSERT (!link_info->relocatable);
0f5f1638 9665 fix = reloc_bfd_fix_init (sec, offset, r_type,
43cd72b9
BW		 9666 r_reloc_get_section (r_rel),
9667 r_rel->target_offset + r_rel->virtual_offset,
9668 FALSE);
9669 /* We also need to mark that relocations are needed here. */
9670 sec->flags |= SEC_RELOC;
9671
9672 translate_reloc_bfd_fix (fix);
9673 /* This fix has not yet been translated. */
9674 add_fix (sec, fix);
9675
9676 /* Add the relocation. If we have already allocated our own
9677 space for the relocations and we have room for more, then use
9678 it. Otherwise, allocate new space and move the literals. */
9679 insert_at = sec->reloc_count;
9680 for (i = 0; i < sec->reloc_count; ++i)
9681 {
9682 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9683 {
9684 insert_at = i;
9685 break;
9686 }
9687 }
9688
9689 if (*internal_relocs_p != relax_info->allocated_relocs
9690 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9691 {
9692 BFD_ASSERT (relax_info->allocated_relocs == NULL
9693 || sec->reloc_count == relax_info->relocs_count);
9694
9695 if (relax_info->allocated_relocs_count == 0)
9696 new_relocs_count = (sec->reloc_count + 2) * 2;
9697 else
9698 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9699
9700 new_relocs = (Elf_Internal_Rela *)
9701 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9702 if (!new_relocs)
9703 return FALSE;
9704
9705 /* We could handle this more quickly by finding the split point. */
9706 if (insert_at != 0)
9707 memcpy (new_relocs, *internal_relocs_p,
9708 insert_at * sizeof (Elf_Internal_Rela));
9709
9710 new_relocs[insert_at] = this_rela;
9711
9712 if (insert_at != sec->reloc_count)
9713 memcpy (new_relocs + insert_at + 1,
9714 (*internal_relocs_p) + insert_at,
9715 (sec->reloc_count - insert_at)
9716 * sizeof (Elf_Internal_Rela));
9717
9718 if (*internal_relocs_p != relax_info->allocated_relocs)
9719 {
9720 /* The first time we re-allocate, we can only free the
9721 old relocs if they were allocated with bfd_malloc.
9722 This is not true when keep_memory is in effect. */
9723 if (!link_info->keep_memory)
9724 free (*internal_relocs_p);
9725 }
9726 else
9727 free (*internal_relocs_p);
9728 relax_info->allocated_relocs = new_relocs;
9729 relax_info->allocated_relocs_count = new_relocs_count;
9730 elf_section_data (sec)->relocs = new_relocs;
9731 sec->reloc_count++;
9732 relax_info->relocs_count = sec->reloc_count;
9733 *internal_relocs_p = new_relocs;
9734 }
9735 else
9736 {
9737 if (insert_at != sec->reloc_count)
9738 {
9739 unsigned idx;
9740 for (idx = sec->reloc_count; idx > insert_at; idx--)
9741 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9742 }
9743 (*internal_relocs_p)[insert_at] = this_rela;
9744 sec->reloc_count++;
9745 if (relax_info->allocated_relocs)
9746 relax_info->relocs_count = sec->reloc_count;
9747 }
9748 }
9749 return TRUE;
9750}
9751
9752
e0001a05
NC		 9753/* This is similar to relax_section except that when a target is moved,
9754 we shift addresses up. We also need to modify the size. This
9755 algorithm does NOT allow for relocations into the middle of the
9756 property sections. */
9757
43cd72b9 9758static bfd_boolean
7fa3d080
BW		 9759relax_property_section (bfd *abfd,
9760 asection *sec,
9761 struct bfd_link_info *link_info)
e0001a05
NC		 9762{
9763 Elf_Internal_Rela *internal_relocs;
9764 bfd_byte *contents;
1d25768e 9765 unsigned i;
e0001a05 9766 bfd_boolean ok = TRUE;
43cd72b9
BW		 9767 bfd_boolean is_full_prop_section;
9768 size_t last_zfill_target_offset = 0;
9769 asection *last_zfill_target_sec = NULL;
9770 bfd_size_type sec_size;
1d25768e 9771 bfd_size_type entry_size;
e0001a05 9772
43cd72b9 9773 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 9774 internal_relocs = retrieve_internal_relocs (abfd, sec,
9775 link_info->keep_memory);
9776 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 9777 if (contents == NULL && sec_size != 0)
e0001a05
NC		 9778 {
9779 ok = FALSE;
9780 goto error_return;
9781 }
9782
1d25768e
BW		 9783 is_full_prop_section = xtensa_is_proptable_section (sec);
9784 if (is_full_prop_section)
9785 entry_size = 12;
9786 else
9787 entry_size = 8;
43cd72b9
BW		 9788
9789 if (internal_relocs)
e0001a05 9790 {
43cd72b9 9791 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 9792 {
9793 Elf_Internal_Rela *irel;
9794 xtensa_relax_info *target_relax_info;
e0001a05
NC		 9795 unsigned r_type;
9796 asection *target_sec;
43cd72b9
BW		 9797 literal_value val;
9798 bfd_byte *size_p, *flags_p;
e0001a05
NC		 9799
9800 /* Locally change the source address.
9801 Translate the target to the new target address.
9802 If it points to this section and has been removed, MOVE IT.
9803 Also, don't forget to modify the associated SIZE at
9804 (offset + 4). */
9805
9806 irel = &internal_relocs[i];
9807 r_type = ELF32_R_TYPE (irel->r_info);
9808 if (r_type == R_XTENSA_NONE)
9809 continue;
9810
43cd72b9
BW		 9811 /* Find the literal value. */
9812 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9813 size_p = &contents[irel->r_offset + 4];
9814 flags_p = NULL;
9815 if (is_full_prop_section)
1d25768e
BW		 9816 flags_p = &contents[irel->r_offset + 8];
9817 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
e0001a05 9818
43cd72b9 9819 target_sec = r_reloc_get_section (&val.r_rel);
e0001a05
NC		 9820 target_relax_info = get_xtensa_relax_info (target_sec);
9821
9822 if (target_relax_info
43cd72b9
BW		 9823 && (target_relax_info->is_relaxable_literal_section
9824 || target_relax_info->is_relaxable_asm_section ))
e0001a05
NC		 9825 {
9826 /* Translate the relocation's destination. */
03669f1c
BW		 9827 bfd_vma old_offset = val.r_rel.target_offset;
9828 bfd_vma new_offset;
e0001a05 9829 long old_size, new_size;
03669f1c
BW		 9830 text_action *act = target_relax_info->action_list.head;
9831 new_offset = old_offset -
9832 removed_by_actions (&act, old_offset, FALSE);
e0001a05
NC		 9833
9834 /* Assert that we are not out of bounds. */
43cd72b9 9835 old_size = bfd_get_32 (abfd, size_p);
03669f1c 9836 new_size = old_size;
43cd72b9
BW		 9837
9838 if (old_size == 0)
9839 {
9840 /* Only the first zero-sized unreachable entry is
9841 allowed to expand. In this case the new offset
9842 should be the offset before the fill and the new
9843 size is the expansion size. For other zero-sized
9844 entries the resulting size should be zero with an
9845 offset before or after the fill address depending
9846 on whether the expanding unreachable entry
9847 preceeds it. */
03669f1c
BW		 9848 if (last_zfill_target_sec == 0
9849 || last_zfill_target_sec != target_sec
9850 || last_zfill_target_offset != old_offset)
43cd72b9 9851 {
03669f1c
BW		 9852 bfd_vma new_end_offset = new_offset;
9853
9854 /* Recompute the new_offset, but this time don't
9855 include any fill inserted by relaxation. */
9856 act = target_relax_info->action_list.head;
9857 new_offset = old_offset -
9858 removed_by_actions (&act, old_offset, TRUE);
43cd72b9
BW		 9859
9860 /* If it is not unreachable and we have not yet
9861 seen an unreachable at this address, place it
9862 before the fill address. */
03669f1c
BW		 9863 if (flags_p && (bfd_get_32 (abfd, flags_p)
9864 & XTENSA_PROP_UNREACHABLE) != 0)
43cd72b9 9865 {
03669f1c
BW		 9866 new_size = new_end_offset - new_offset;
9867
43cd72b9 9868 last_zfill_target_sec = target_sec;
03669f1c 9869 last_zfill_target_offset = old_offset;
43cd72b9
BW		 9870 }
9871 }
9872 }
9873 else
03669f1c
BW		 9874 new_size -=
9875 removed_by_actions (&act, old_offset + old_size, TRUE);
43cd72b9 9876
e0001a05
NC		 9877 if (new_size != old_size)
9878 {
9879 bfd_put_32 (abfd, new_size, size_p);
9880 pin_contents (sec, contents);
9881 }
43cd72b9 9882
03669f1c 9883 if (new_offset != old_offset)
e0001a05 9884 {
03669f1c 9885 bfd_vma diff = new_offset - old_offset;
e0001a05
NC		 9886 irel->r_addend += diff;
9887 pin_internal_relocs (sec, internal_relocs);
9888 }
9889 }
9890 }
9891 }
9892
9893 /* Combine adjacent property table entries. This is also done in
9894 finish_dynamic_sections() but at that point it's too late to
9895 reclaim the space in the output section, so we do this twice. */
9896
43cd72b9 9897 if (internal_relocs && (!link_info->relocatable
1d25768e 9898 || xtensa_is_littable_section (sec)))
e0001a05
NC		 9899 {
9900 Elf_Internal_Rela *last_irel = NULL;
1d25768e 9901 Elf_Internal_Rela *irel, *next_rel, *rel_end;
e0001a05 9902 int removed_bytes = 0;
1d25768e 9903 bfd_vma offset;
43cd72b9
BW		 9904 flagword predef_flags;
9905
43cd72b9 9906 predef_flags = xtensa_get_property_predef_flags (sec);
e0001a05 9907
1d25768e 9908 /* Walk over memory and relocations at the same time.
e0001a05
NC		 9909 This REQUIRES that the internal_relocs be sorted by offset. */
9910 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9911 internal_reloc_compare);
e0001a05
NC		 9912
9913 pin_internal_relocs (sec, internal_relocs);
9914 pin_contents (sec, contents);
9915
1d25768e
BW		 9916 next_rel = internal_relocs;
9917 rel_end = internal_relocs + sec->reloc_count;
9918
a3ef2d63 9919 BFD_ASSERT (sec->size % entry_size == 0);
e0001a05 9920
a3ef2d63 9921 for (offset = 0; offset < sec->size; offset += entry_size)
e0001a05 9922 {
1d25768e 9923 Elf_Internal_Rela *offset_rel, *extra_rel;
e0001a05 9924 bfd_vma bytes_to_remove, size, actual_offset;
1d25768e 9925 bfd_boolean remove_this_rel;
43cd72b9 9926 flagword flags;
e0001a05 9927
1d25768e
BW		 9928 /* Find the first relocation for the entry at the current offset.
9929 Adjust the offsets of any extra relocations for the previous
9930 entry. */
9931 offset_rel = NULL;
9932 if (next_rel)
9933 {
9934 for (irel = next_rel; irel < rel_end; irel++)
9935 {
9936 if ((irel->r_offset == offset
9937 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9938 || irel->r_offset > offset)
9939 {
9940 offset_rel = irel;
9941 break;
9942 }
9943 irel->r_offset -= removed_bytes;
1d25768e
BW		 9944 }
9945 }
e0001a05 9946
1d25768e
BW		 9947 /* Find the next relocation (if there are any left). */
9948 extra_rel = NULL;
9949 if (offset_rel)
e0001a05 9950 {
1d25768e 9951 for (irel = offset_rel + 1; irel < rel_end; irel++)
e0001a05 9952 {
1d25768e
BW		 9953 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9954 {
9955 extra_rel = irel;
9956 break;
9957 }
e0001a05 9958 }
e0001a05
NC		 9959 }
9960
1d25768e
BW		 9961 /* Check if there are relocations on the current entry. There
9962 should usually be a relocation on the offset field. If there
9963 are relocations on the size or flags, then we can't optimize
9964 this entry. Also, find the next relocation to examine on the
9965 next iteration. */
9966 if (offset_rel)
e0001a05 9967 {
1d25768e 9968 if (offset_rel->r_offset >= offset + entry_size)
e0001a05 9969 {
1d25768e
BW		 9970 next_rel = offset_rel;
9971 /* There are no relocations on the current entry, but we
9972 might still be able to remove it if the size is zero. */
9973 offset_rel = NULL;
9974 }
9975 else if (offset_rel->r_offset > offset
9976 || (extra_rel
9977 && extra_rel->r_offset < offset + entry_size))
9978 {
9979 /* There is a relocation on the size or flags, so we can't
9980 do anything with this entry. Continue with the next. */
9981 next_rel = offset_rel;
9982 continue;
9983 }
9984 else
9985 {
9986 BFD_ASSERT (offset_rel->r_offset == offset);
9987 offset_rel->r_offset -= removed_bytes;
9988 next_rel = offset_rel + 1;
e0001a05 9989 }
e0001a05 9990 }
1d25768e
BW		 9991 else
9992 next_rel = NULL;
e0001a05 9993
1d25768e 9994 remove_this_rel = FALSE;
e0001a05
NC		 9995 bytes_to_remove = 0;
9996 actual_offset = offset - removed_bytes;
9997 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9998
43cd72b9
BW		 9999 if (is_full_prop_section)
10000 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10001 else
10002 flags = predef_flags;
10003
1d25768e
BW		 10004 if (size == 0
10005 && (flags & XTENSA_PROP_ALIGN) == 0
10006 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
e0001a05 10007 {
43cd72b9
BW		 10008 /* Always remove entries with zero size and no alignment. */
10009 bytes_to_remove = entry_size;
1d25768e
BW		 10010 if (offset_rel)
10011 remove_this_rel = TRUE;
e0001a05 10012 }
1d25768e
BW		 10013 else if (offset_rel
10014 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
e0001a05 10015 {
1d25768e 10016 if (last_irel)
e0001a05 10017 {
1d25768e
BW		 10018 flagword old_flags;
10019 bfd_vma old_size =
10020 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10021 bfd_vma old_address =
10022 (last_irel->r_addend
10023 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10024 bfd_vma new_address =
10025 (offset_rel->r_addend
10026 + bfd_get_32 (abfd, &contents[actual_offset]));
10027 if (is_full_prop_section)
10028 old_flags = bfd_get_32
10029 (abfd, &contents[last_irel->r_offset + 8]);
10030 else
10031 old_flags = predef_flags;
10032
10033 if ((ELF32_R_SYM (offset_rel->r_info)
10034 == ELF32_R_SYM (last_irel->r_info))
10035 && old_address + old_size == new_address
10036 && old_flags == flags
10037 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10038 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
e0001a05 10039 {
1d25768e
BW		 10040 /* Fix the old size. */
10041 bfd_put_32 (abfd, old_size + size,
10042 &contents[last_irel->r_offset + 4]);
10043 bytes_to_remove = entry_size;
10044 remove_this_rel = TRUE;
e0001a05
NC		 10045 }
10046 else
1d25768e 10047 last_irel = offset_rel;
e0001a05 10048 }
1d25768e
BW		 10049 else
10050 last_irel = offset_rel;
e0001a05
NC		 10051 }
10052
1d25768e 10053 if (remove_this_rel)
e0001a05 10054 {
1d25768e 10055 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3df502ae 10056 offset_rel->r_offset = 0;
e0001a05
NC		 10057 }
10058
10059 if (bytes_to_remove != 0)
10060 {
10061 removed_bytes += bytes_to_remove;
a3ef2d63 10062 if (offset + bytes_to_remove < sec->size)
e0001a05 10063 memmove (&contents[actual_offset],
43cd72b9 10064 &contents[actual_offset + bytes_to_remove],
a3ef2d63 10065 sec->size - offset - bytes_to_remove);
e0001a05
NC		 10066 }
10067 }
10068
43cd72b9 10069 if (removed_bytes)
e0001a05 10070 {
1d25768e
BW		 10071 /* Fix up any extra relocations on the last entry. */
10072 for (irel = next_rel; irel < rel_end; irel++)
10073 irel->r_offset -= removed_bytes;
10074
e0001a05 10075 /* Clear the removed bytes. */
a3ef2d63 10076 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
e0001a05 10077
a3ef2d63
BW		 10078 if (sec->rawsize == 0)
10079 sec->rawsize = sec->size;
10080 sec->size -= removed_bytes;
e901de89
BW		 10081
10082 if (xtensa_is_littable_section (sec))
10083 {
f0e6fdb2
BW		 10084 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10085 if (sgotloc)
10086 sgotloc->size -= removed_bytes;
e901de89 10087 }
e0001a05
NC		 10088 }
10089 }
e901de89 10090
e0001a05
NC		 10091 error_return:
10092 release_internal_relocs (sec, internal_relocs);
10093 release_contents (sec, contents);
10094 return ok;
10095}
10096
10097\f
10098/* Third relaxation pass. */
10099
10100/* Change symbol values to account for removed literals. */
10101
43cd72b9 10102bfd_boolean
7fa3d080 10103relax_section_symbols (bfd *abfd, asection *sec)
e0001a05
NC		 10104{
10105 xtensa_relax_info *relax_info;
10106 unsigned int sec_shndx;
10107 Elf_Internal_Shdr *symtab_hdr;
10108 Elf_Internal_Sym *isymbuf;
10109 unsigned i, num_syms, num_locals;
10110
10111 relax_info = get_xtensa_relax_info (sec);
10112 BFD_ASSERT (relax_info);
10113
43cd72b9
BW		 10114 if (!relax_info->is_relaxable_literal_section
10115 && !relax_info->is_relaxable_asm_section)
e0001a05
NC		 10116 return TRUE;
10117
10118 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10119
10120 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10121 isymbuf = retrieve_local_syms (abfd);
10122
10123 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10124 num_locals = symtab_hdr->sh_info;
10125
10126 /* Adjust the local symbols defined in this section. */
10127 for (i = 0; i < num_locals; i++)
10128 {
10129 Elf_Internal_Sym *isym = &isymbuf[i];
10130
10131 if (isym->st_shndx == sec_shndx)
10132 {
03669f1c
BW		 10133 text_action *act = relax_info->action_list.head;
10134 bfd_vma orig_addr = isym->st_value;
43cd72b9 10135
03669f1c 10136 isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
43cd72b9 10137
03669f1c
BW		 10138 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10139 isym->st_size -=
10140 removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
e0001a05
NC		 10141 }
10142 }
10143
10144 /* Now adjust the global symbols defined in this section. */
10145 for (i = 0; i < (num_syms - num_locals); i++)
10146 {
10147 struct elf_link_hash_entry *sym_hash;
10148
10149 sym_hash = elf_sym_hashes (abfd)[i];
10150
10151 if (sym_hash->root.type == bfd_link_hash_warning)
10152 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10153
10154 if ((sym_hash->root.type == bfd_link_hash_defined
10155 || sym_hash->root.type == bfd_link_hash_defweak)
10156 && sym_hash->root.u.def.section == sec)
10157 {
03669f1c
BW		 10158 text_action *act = relax_info->action_list.head;
10159 bfd_vma orig_addr = sym_hash->root.u.def.value;
43cd72b9 10160
03669f1c
BW		 10161 sym_hash->root.u.def.value -=
10162 removed_by_actions (&act, orig_addr, FALSE);
43cd72b9 10163
03669f1c
BW		 10164 if (sym_hash->type == STT_FUNC)
10165 sym_hash->size -=
10166 removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
e0001a05
NC		 10167 }
10168 }
10169
10170 return TRUE;
10171}
10172
10173\f
10174/* "Fix" handling functions, called while performing relocations. */
10175
43cd72b9 10176static bfd_boolean
7fa3d080
BW		 10177do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10178 bfd *input_bfd,
10179 asection *input_section,
10180 bfd_byte *contents)
e0001a05
NC		 10181{
10182 r_reloc r_rel;
10183 asection *sec, *old_sec;
10184 bfd_vma old_offset;
10185 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05
NC		 10186 reloc_bfd_fix *fix;
10187
10188 if (r_type == R_XTENSA_NONE)
43cd72b9 10189 return TRUE;
e0001a05 10190
43cd72b9
BW		 10191 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10192 if (!fix)
10193 return TRUE;
e0001a05 10194
43cd72b9
BW		 10195 r_reloc_init (&r_rel, input_bfd, rel, contents,
10196 bfd_get_section_limit (input_bfd, input_section));
e0001a05 10197 old_sec = r_reloc_get_section (&r_rel);
43cd72b9
BW		 10198 old_offset = r_rel.target_offset;
10199
10200 if (!old_sec || !r_reloc_is_defined (&r_rel))
e0001a05 10201 {
43cd72b9
BW		 10202 if (r_type != R_XTENSA_ASM_EXPAND)
10203 {
10204 (*_bfd_error_handler)
10205 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10206 input_bfd, input_section, rel->r_offset,
10207 elf_howto_table[r_type].name);
10208 return FALSE;
10209 }
e0001a05
NC		 10210 /* Leave it be. Resolution will happen in a later stage. */
10211 }
10212 else
10213 {
10214 sec = fix->target_sec;
10215 rel->r_addend += ((sec->output_offset + fix->target_offset)
10216 - (old_sec->output_offset + old_offset));
10217 }
43cd72b9 10218 return TRUE;
e0001a05
NC		 10219}
10220
10221
10222static void
7fa3d080
BW		 10223do_fix_for_final_link (Elf_Internal_Rela *rel,
10224 bfd *input_bfd,
10225 asection *input_section,
10226 bfd_byte *contents,
10227 bfd_vma *relocationp)
e0001a05
NC		 10228{
10229 asection *sec;
10230 int r_type = ELF32_R_TYPE (rel->r_info);
e0001a05 10231 reloc_bfd_fix *fix;
43cd72b9 10232 bfd_vma fixup_diff;
e0001a05
NC		 10233
10234 if (r_type == R_XTENSA_NONE)
10235 return;
10236
43cd72b9
BW		 10237 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10238 if (!fix)
e0001a05
NC		 10239 return;
10240
10241 sec = fix->target_sec;
43cd72b9
BW		 10242
10243 fixup_diff = rel->r_addend;
10244 if (elf_howto_table[fix->src_type].partial_inplace)
10245 {
10246 bfd_vma inplace_val;
10247 BFD_ASSERT (fix->src_offset
10248 < bfd_get_section_limit (input_bfd, input_section));
10249 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10250 fixup_diff += inplace_val;
10251 }
10252
e0001a05
NC		 10253 *relocationp = (sec->output_section->vma
10254 + sec->output_offset
43cd72b9 10255 + fix->target_offset - fixup_diff);
e0001a05
NC		 10256}
10257
10258\f
10259/* Miscellaneous utility functions.... */
10260
10261static asection *
f0e6fdb2 10262elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
e0001a05 10263{
f0e6fdb2
BW		 10264 struct elf_xtensa_link_hash_table *htab;
10265 bfd *dynobj;
e0001a05
NC		 10266 char plt_name[10];
10267
10268 if (chunk == 0)
f0e6fdb2
BW		 10269 {
10270 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 10271 if (htab == NULL)
10272 return NULL;
10273
f0e6fdb2
BW		 10274 return htab->splt;
10275 }
e0001a05 10276
f0e6fdb2 10277 dynobj = elf_hash_table (info)->dynobj;
e0001a05 10278 sprintf (plt_name, ".plt.%u", chunk);
3d4d4302 10279 return bfd_get_linker_section (dynobj, plt_name);
e0001a05
NC		 10280}
10281
10282
10283static asection *
f0e6fdb2 10284elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
e0001a05 10285{
f0e6fdb2
BW		 10286 struct elf_xtensa_link_hash_table *htab;
10287 bfd *dynobj;
e0001a05
NC		 10288 char got_name[14];
10289
10290 if (chunk == 0)
f0e6fdb2
BW		 10291 {
10292 htab = elf_xtensa_hash_table (info);
4dfe6ac6
NC		 10293 if (htab == NULL)
10294 return NULL;
f0e6fdb2
BW		 10295 return htab->sgotplt;
10296 }
e0001a05 10297
f0e6fdb2 10298 dynobj = elf_hash_table (info)->dynobj;
e0001a05 10299 sprintf (got_name, ".got.plt.%u", chunk);
3d4d4302 10300 return bfd_get_linker_section (dynobj, got_name);
e0001a05
NC		 10301}
10302
10303
10304/* Get the input section for a given symbol index.
10305 If the symbol is:
10306 . a section symbol, return the section;
10307 . a common symbol, return the common section;
10308 . an undefined symbol, return the undefined section;
10309 . an indirect symbol, follow the links;
10310 . an absolute value, return the absolute section. */
10311
10312static asection *
7fa3d080 10313get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10314{
10315 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10316 asection *target_sec = NULL;
43cd72b9 10317 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 10318 {
10319 Elf_Internal_Sym *isymbuf;
10320 unsigned int section_index;
10321
10322 isymbuf = retrieve_local_syms (abfd);
10323 section_index = isymbuf[r_symndx].st_shndx;
10324
10325 if (section_index == SHN_UNDEF)
10326 target_sec = bfd_und_section_ptr;
e0001a05
NC		 10327 else if (section_index == SHN_ABS)
10328 target_sec = bfd_abs_section_ptr;
10329 else if (section_index == SHN_COMMON)
10330 target_sec = bfd_com_section_ptr;
43cd72b9 10331 else
cb33740c 10332 target_sec = bfd_section_from_elf_index (abfd, section_index);
e0001a05
NC		 10333 }
10334 else
10335 {
10336 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10337 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10338
10339 while (h->root.type == bfd_link_hash_indirect
10340 || h->root.type == bfd_link_hash_warning)
10341 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10342
10343 switch (h->root.type)
10344 {
10345 case bfd_link_hash_defined:
10346 case bfd_link_hash_defweak:
10347 target_sec = h->root.u.def.section;
10348 break;
10349 case bfd_link_hash_common:
10350 target_sec = bfd_com_section_ptr;
10351 break;
10352 case bfd_link_hash_undefined:
10353 case bfd_link_hash_undefweak:
10354 target_sec = bfd_und_section_ptr;
10355 break;
10356 default: /* New indirect warning. */
10357 target_sec = bfd_und_section_ptr;
10358 break;
10359 }
10360 }
10361 return target_sec;
10362}
10363
10364
10365static struct elf_link_hash_entry *
7fa3d080 10366get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10367{
10368 unsigned long indx;
10369 struct elf_link_hash_entry *h;
10370 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10371
10372 if (r_symndx < symtab_hdr->sh_info)
10373 return NULL;
43cd72b9 10374
e0001a05
NC		 10375 indx = r_symndx - symtab_hdr->sh_info;
10376 h = elf_sym_hashes (abfd)[indx];
10377 while (h->root.type == bfd_link_hash_indirect
10378 || h->root.type == bfd_link_hash_warning)
10379 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10380 return h;
10381}
10382
10383
10384/* Get the section-relative offset for a symbol number. */
10385
10386static bfd_vma
7fa3d080 10387get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
e0001a05
NC		 10388{
10389 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10390 bfd_vma offset = 0;
10391
43cd72b9 10392 if (r_symndx < symtab_hdr->sh_info)
e0001a05
NC		 10393 {
10394 Elf_Internal_Sym *isymbuf;
10395 isymbuf = retrieve_local_syms (abfd);
10396 offset = isymbuf[r_symndx].st_value;
10397 }
10398 else
10399 {
10400 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10401 struct elf_link_hash_entry *h =
10402 elf_sym_hashes (abfd)[indx];
10403
10404 while (h->root.type == bfd_link_hash_indirect
10405 || h->root.type == bfd_link_hash_warning)
10406 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10407 if (h->root.type == bfd_link_hash_defined
10408 || h->root.type == bfd_link_hash_defweak)
10409 offset = h->root.u.def.value;
10410 }
10411 return offset;
10412}
10413
10414
10415static bfd_boolean
7fa3d080 10416is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
43cd72b9
BW		 10417{
10418 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10419 struct elf_link_hash_entry *h;
10420
10421 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10422 if (h && h->root.type == bfd_link_hash_defweak)
10423 return TRUE;
10424 return FALSE;
10425}
10426
10427
10428static bfd_boolean
7fa3d080
BW		 10429pcrel_reloc_fits (xtensa_opcode opc,
10430 int opnd,
10431 bfd_vma self_address,
10432 bfd_vma dest_address)
e0001a05 10433{
43cd72b9
BW		 10434 xtensa_isa isa = xtensa_default_isa;
10435 uint32 valp = dest_address;
10436 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10437 || xtensa_operand_encode (isa, opc, opnd, &valp))
10438 return FALSE;
10439 return TRUE;
e0001a05
NC		 10440}
10441
10442
10443static bfd_boolean
7fa3d080 10444xtensa_is_property_section (asection *sec)
e0001a05 10445{
1d25768e
BW		 10446 if (xtensa_is_insntable_section (sec)
10447 || xtensa_is_littable_section (sec)
10448 || xtensa_is_proptable_section (sec))
b614a702 10449 return TRUE;
e901de89 10450
1d25768e
BW		 10451 return FALSE;
10452}
10453
10454
10455static bfd_boolean
10456xtensa_is_insntable_section (asection *sec)
10457{
10458 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10459 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
e901de89
BW		 10460 return TRUE;
10461
e901de89
BW		 10462 return FALSE;
10463}
10464
10465
10466static bfd_boolean
7fa3d080 10467xtensa_is_littable_section (asection *sec)
e901de89 10468{
1d25768e
BW		 10469 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10470 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
b614a702 10471 return TRUE;
e901de89 10472
1d25768e
BW		 10473 return FALSE;
10474}
10475
10476
10477static bfd_boolean
10478xtensa_is_proptable_section (asection *sec)
10479{
10480 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10481 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
e901de89 10482 return TRUE;
e0001a05 10483
e901de89 10484 return FALSE;
e0001a05
NC		 10485}
10486
10487
43cd72b9 10488static int
7fa3d080 10489internal_reloc_compare (const void *ap, const void *bp)
e0001a05 10490{
43cd72b9
BW		 10491 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10492 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10493
10494 if (a->r_offset != b->r_offset)
10495 return (a->r_offset - b->r_offset);
10496
10497 /* We don't need to sort on these criteria for correctness,
10498 but enforcing a more strict ordering prevents unstable qsort
10499 from behaving differently with different implementations.
10500 Without the code below we get correct but different results
10501 on Solaris 2.7 and 2.8. We would like to always produce the
10502 same results no matter the host. */
10503
10504 if (a->r_info != b->r_info)
10505 return (a->r_info - b->r_info);
10506
10507 return (a->r_addend - b->r_addend);
e0001a05
NC		 10508}
10509
10510
10511static int
7fa3d080 10512internal_reloc_matches (const void *ap, const void *bp)
e0001a05
NC		 10513{
10514 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10515 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10516
43cd72b9
BW		 10517 /* Check if one entry overlaps with the other; this shouldn't happen
10518 except when searching for a match. */
e0001a05
NC		 10519 return (a->r_offset - b->r_offset);
10520}
10521
10522
74869ac7
BW		 10523/* Predicate function used to look up a section in a particular group. */
10524
10525static bfd_boolean
10526match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10527{
10528 const char *gname = inf;
10529 const char *group_name = elf_group_name (sec);
10530
10531 return (group_name == gname
10532 || (group_name != NULL
10533 && gname != NULL
10534 && strcmp (group_name, gname) == 0));
10535}
10536
10537
1d25768e
BW		 10538static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10539
51c8ebc1
BW		 10540static char *
10541xtensa_property_section_name (asection *sec, const char *base_name)
e0001a05 10542{
74869ac7
BW		 10543 const char *suffix, *group_name;
10544 char *prop_sec_name;
74869ac7
BW		 10545
10546 group_name = elf_group_name (sec);
10547 if (group_name)
10548 {
10549 suffix = strrchr (sec->name, '.');
10550 if (suffix == sec->name)
10551 suffix = 0;
10552 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10553 + (suffix ? strlen (suffix) : 0));
10554 strcpy (prop_sec_name, base_name);
10555 if (suffix)
10556 strcat (prop_sec_name, suffix);
10557 }
10558 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
e0001a05 10559 {
43cd72b9 10560 char *linkonce_kind = 0;
b614a702
BW		 10561
10562 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
7db48a12 10563 linkonce_kind = "x.";
b614a702 10564 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
7db48a12 10565 linkonce_kind = "p.";
43cd72b9
BW		 10566 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10567 linkonce_kind = "prop.";
e0001a05 10568 else
b614a702
BW		 10569 abort ();
10570
43cd72b9
BW		 10571 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10572 + strlen (linkonce_kind) + 1);
b614a702 10573 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
43cd72b9 10574 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
b614a702
BW		 10575
10576 suffix = sec->name + linkonce_len;
096c35a7 10577 /* For backward compatibility, replace "t." instead of inserting
43cd72b9 10578 the new linkonce_kind (but not for "prop" sections). */
0112cd26 10579 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
43cd72b9
BW		 10580 suffix += 2;
10581 strcat (prop_sec_name + linkonce_len, suffix);
74869ac7
BW		 10582 }
10583 else
10584 prop_sec_name = strdup (base_name);
10585
51c8ebc1
BW		 10586 return prop_sec_name;
10587}
10588
10589
10590static asection *
10591xtensa_get_property_section (asection *sec, const char *base_name)
10592{
10593 char *prop_sec_name;
10594 asection *prop_sec;
10595
10596 prop_sec_name = xtensa_property_section_name (sec, base_name);
10597 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10598 match_section_group,
10599 (void *) elf_group_name (sec));
10600 free (prop_sec_name);
10601 return prop_sec;
10602}
10603
10604
10605asection *
10606xtensa_make_property_section (asection *sec, const char *base_name)
10607{
10608 char *prop_sec_name;
10609 asection *prop_sec;
10610
74869ac7 10611 /* Check if the section already exists. */
51c8ebc1 10612 prop_sec_name = xtensa_property_section_name (sec, base_name);
74869ac7
BW		 10613 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10614 match_section_group,
51c8ebc1 10615 (void *) elf_group_name (sec));
74869ac7
BW		 10616 /* If not, create it. */
10617 if (! prop_sec)
10618 {
10619 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10620 flags |= (bfd_get_section_flags (sec->owner, sec)
10621 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10622
10623 prop_sec = bfd_make_section_anyway_with_flags
10624 (sec->owner, strdup (prop_sec_name), flags);
10625 if (! prop_sec)
10626 return 0;
b614a702 10627
51c8ebc1 10628 elf_group_name (prop_sec) = elf_group_name (sec);
e0001a05
NC		 10629 }
10630
74869ac7
BW		 10631 free (prop_sec_name);
10632 return prop_sec;
e0001a05
NC		 10633}
10634
43cd72b9
BW		 10635
10636flagword
7fa3d080 10637xtensa_get_property_predef_flags (asection *sec)
43cd72b9 10638{
1d25768e 10639 if (xtensa_is_insntable_section (sec))
43cd72b9 10640 return (XTENSA_PROP_INSN
99ded152 10641 | XTENSA_PROP_NO_TRANSFORM
43cd72b9
BW		 10642 | XTENSA_PROP_INSN_NO_REORDER);
10643
10644 if (xtensa_is_littable_section (sec))
10645 return (XTENSA_PROP_LITERAL
99ded152 10646 | XTENSA_PROP_NO_TRANSFORM
43cd72b9
BW		 10647 | XTENSA_PROP_INSN_NO_REORDER);
10648
10649 return 0;
10650}
10651
e0001a05
NC		 10652\f
10653/* Other functions called directly by the linker. */
10654
10655bfd_boolean
7fa3d080
BW		 10656xtensa_callback_required_dependence (bfd *abfd,
10657 asection *sec,
10658 struct bfd_link_info *link_info,
10659 deps_callback_t callback,
10660 void *closure)
e0001a05
NC		 10661{
10662 Elf_Internal_Rela *internal_relocs;
10663 bfd_byte *contents;
10664 unsigned i;
10665 bfd_boolean ok = TRUE;
43cd72b9
BW		 10666 bfd_size_type sec_size;
10667
10668 sec_size = bfd_get_section_limit (abfd, sec);
e0001a05
NC		 10669
10670 /* ".plt*" sections have no explicit relocations but they contain L32R
10671 instructions that reference the corresponding ".got.plt*" sections. */
10672 if ((sec->flags & SEC_LINKER_CREATED) != 0
0112cd26 10673 && CONST_STRNEQ (sec->name, ".plt"))
e0001a05
NC		 10674 {
10675 asection *sgotplt;
10676
10677 /* Find the corresponding ".got.plt*" section. */
10678 if (sec->name[4] == '\0')
3d4d4302 10679 sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");
e0001a05
NC		 10680 else
10681 {
10682 char got_name[14];
10683 int chunk = 0;
10684
10685 BFD_ASSERT (sec->name[4] == '.');
10686 chunk = strtol (&sec->name[5], NULL, 10);
10687
10688 sprintf (got_name, ".got.plt.%u", chunk);
3d4d4302 10689 sgotplt = bfd_get_linker_section (sec->owner, got_name);
e0001a05
NC		 10690 }
10691 BFD_ASSERT (sgotplt);
10692
10693 /* Assume worst-case offsets: L32R at the very end of the ".plt"
10694 section referencing a literal at the very beginning of
10695 ".got.plt". This is very close to the real dependence, anyway. */
43cd72b9 10696 (*callback) (sec, sec_size, sgotplt, 0, closure);
e0001a05
NC		 10697 }
10698
13161072
BW		 10699 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
10700 when building uclibc, which runs "ld -b binary /dev/null". */
10701 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10702 return ok;
10703
e0001a05
NC		 10704 internal_relocs = retrieve_internal_relocs (abfd, sec,
10705 link_info->keep_memory);
10706 if (internal_relocs == NULL
43cd72b9 10707 || sec->reloc_count == 0)
e0001a05
NC		 10708 return ok;
10709
10710 /* Cache the contents for the duration of this scan. */
10711 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
43cd72b9 10712 if (contents == NULL && sec_size != 0)
e0001a05
NC		 10713 {
10714 ok = FALSE;
10715 goto error_return;
10716 }
10717
43cd72b9
BW		 10718 if (!xtensa_default_isa)
10719 xtensa_default_isa = xtensa_isa_init (0, 0);
e0001a05 10720
43cd72b9 10721 for (i = 0; i < sec->reloc_count; i++)
e0001a05
NC		 10722 {
10723 Elf_Internal_Rela *irel = &internal_relocs[i];
43cd72b9 10724 if (is_l32r_relocation (abfd, sec, contents, irel))
e0001a05
NC		 10725 {
10726 r_reloc l32r_rel;
10727 asection *target_sec;
10728 bfd_vma target_offset;
43cd72b9
BW		 10729
10730 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
e0001a05
NC		 10731 target_sec = NULL;
10732 target_offset = 0;
10733 /* L32Rs must be local to the input file. */
10734 if (r_reloc_is_defined (&l32r_rel))
10735 {
10736 target_sec = r_reloc_get_section (&l32r_rel);
43cd72b9 10737 target_offset = l32r_rel.target_offset;
e0001a05
NC		 10738 }
10739 (*callback) (sec, irel->r_offset, target_sec, target_offset,
10740 closure);
10741 }
10742 }
10743
10744 error_return:
10745 release_internal_relocs (sec, internal_relocs);
10746 release_contents (sec, contents);
10747 return ok;
10748}
10749
2f89ff8d
L		 10750/* The default literal sections should always be marked as "code" (i.e.,
10751 SHF_EXECINSTR). This is particularly important for the Linux kernel
10752 module loader so that the literals are not placed after the text. */
b35d266b 10753static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
2f89ff8d 10754{
0112cd26
NC		 10755 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10756 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10757 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2caa7ca0 10758 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
0112cd26 10759 { NULL, 0, 0, 0, 0 }
7f4d3958 10760};
e0001a05 10761\f
ae95ffa6 10762#define ELF_TARGET_ID XTENSA_ELF_DATA
e0001a05
NC		 10763#ifndef ELF_ARCH
10764#define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
10765#define TARGET_LITTLE_NAME "elf32-xtensa-le"
10766#define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
10767#define TARGET_BIG_NAME "elf32-xtensa-be"
10768#define ELF_ARCH bfd_arch_xtensa
10769
4af0a1d8
BW		 10770#define ELF_MACHINE_CODE EM_XTENSA
10771#define ELF_MACHINE_ALT1 EM_XTENSA_OLD
e0001a05
NC		 10772
10773#if XCHAL_HAVE_MMU
10774#define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10775#else /* !XCHAL_HAVE_MMU */
10776#define ELF_MAXPAGESIZE 1
10777#endif /* !XCHAL_HAVE_MMU */
10778#endif /* ELF_ARCH */
10779
10780#define elf_backend_can_gc_sections 1
10781#define elf_backend_can_refcount 1
10782#define elf_backend_plt_readonly 1
10783#define elf_backend_got_header_size 4
10784#define elf_backend_want_dynbss 0
10785#define elf_backend_want_got_plt 1
10786
10787#define elf_info_to_howto elf_xtensa_info_to_howto_rela
10788
28dbbc02
BW		 10789#define bfd_elf32_mkobject elf_xtensa_mkobject
10790
e0001a05
NC		 10791#define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10792#define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
10793#define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10794#define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
10795#define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
157090f7
AM		 10796#define bfd_elf32_bfd_reloc_name_lookup \
10797 elf_xtensa_reloc_name_lookup
e0001a05 10798#define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
f0e6fdb2 10799#define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
e0001a05
NC		 10800
10801#define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
10802#define elf_backend_check_relocs elf_xtensa_check_relocs
e0001a05
NC		 10803#define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
10804#define elf_backend_discard_info elf_xtensa_discard_info
10805#define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
10806#define elf_backend_final_write_processing elf_xtensa_final_write_processing
10807#define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
10808#define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
10809#define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
10810#define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
10811#define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
10812#define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
95147441 10813#define elf_backend_hide_symbol elf_xtensa_hide_symbol
e0001a05
NC		 10814#define elf_backend_object_p elf_xtensa_object_p
10815#define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
10816#define elf_backend_relocate_section elf_xtensa_relocate_section
10817#define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
28dbbc02 10818#define elf_backend_always_size_sections elf_xtensa_always_size_sections
74541ad4
AM		 10819#define elf_backend_omit_section_dynsym \
10820 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
29ef7005 10821#define elf_backend_special_sections elf_xtensa_special_sections
a77dc2cc 10822#define elf_backend_action_discarded elf_xtensa_action_discarded
28dbbc02 10823#define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
e0001a05
NC		 10824
10825#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.159959 seconds and 4 git commands to generate.