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