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