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