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