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