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