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