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