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