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