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