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