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