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 /* Main interface functions. */ 39 static void elf_xtensa_info_to_howto_rela 40 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 41 static reloc_howto_type *elf_xtensa_reloc_type_lookup 42 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); 43 extern int xtensa_read_table_entries 44 PARAMS ((bfd *, asection *, property_table_entry **, const char *)); 45 static bfd_boolean elf_xtensa_check_relocs 46 PARAMS ((bfd *, struct bfd_link_info *, asection *, 47 const Elf_Internal_Rela *)); 48 static void elf_xtensa_hide_symbol 49 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean)); 50 static asection *elf_xtensa_gc_mark_hook 51 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, 52 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 53 static bfd_boolean elf_xtensa_gc_sweep_hook 54 PARAMS ((bfd *, struct bfd_link_info *, asection *, 55 const Elf_Internal_Rela *)); 56 static bfd_boolean elf_xtensa_create_dynamic_sections 57 PARAMS ((bfd *, struct bfd_link_info *)); 58 static bfd_boolean elf_xtensa_adjust_dynamic_symbol 59 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 60 static bfd_boolean elf_xtensa_size_dynamic_sections 61 PARAMS ((bfd *, struct bfd_link_info *)); 62 static bfd_boolean elf_xtensa_modify_segment_map 63 PARAMS ((bfd *, struct bfd_link_info *)); 64 static bfd_boolean elf_xtensa_relocate_section 65 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 66 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 67 static bfd_boolean elf_xtensa_relax_section 68 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *again)); 69 static bfd_boolean elf_xtensa_finish_dynamic_symbol 70 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 71 Elf_Internal_Sym *)); 72 static bfd_boolean elf_xtensa_finish_dynamic_sections 73 PARAMS ((bfd *, struct bfd_link_info *)); 74 static bfd_boolean elf_xtensa_merge_private_bfd_data 75 PARAMS ((bfd *, bfd *)); 76 static bfd_boolean elf_xtensa_set_private_flags 77 PARAMS ((bfd *, flagword)); 78 extern flagword elf_xtensa_get_private_bfd_flags 79 PARAMS ((bfd *)); 80 static bfd_boolean elf_xtensa_print_private_bfd_data 81 PARAMS ((bfd *, PTR)); 82 static bfd_boolean elf_xtensa_object_p 83 PARAMS ((bfd *)); 84 static void elf_xtensa_final_write_processing 85 PARAMS ((bfd *, bfd_boolean)); 86 static enum elf_reloc_type_class elf_xtensa_reloc_type_class 87 PARAMS ((const Elf_Internal_Rela *)); 88 static bfd_boolean elf_xtensa_discard_info 89 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *)); 90 static bfd_boolean elf_xtensa_ignore_discarded_relocs 91 PARAMS ((asection *)); 92 static bfd_boolean elf_xtensa_grok_prstatus 93 PARAMS ((bfd *, Elf_Internal_Note *)); 94 static bfd_boolean elf_xtensa_grok_psinfo 95 PARAMS ((bfd *, Elf_Internal_Note *)); 96 static bfd_boolean elf_xtensa_new_section_hook 97 PARAMS ((bfd *, asection *)); 98 99 100 /* Local helper functions. */ 101 102 static bfd_boolean xtensa_elf_dynamic_symbol_p 103 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *)); 104 static int property_table_compare 105 PARAMS ((const PTR, const PTR)); 106 static bfd_boolean elf_xtensa_in_literal_pool 107 PARAMS ((property_table_entry *, int, bfd_vma)); 108 static void elf_xtensa_make_sym_local 109 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 110 static bfd_boolean add_extra_plt_sections 111 PARAMS ((bfd *, int)); 112 static bfd_boolean elf_xtensa_fix_refcounts 113 PARAMS ((struct elf_link_hash_entry *, PTR)); 114 static bfd_boolean elf_xtensa_allocate_plt_size 115 PARAMS ((struct elf_link_hash_entry *, PTR)); 116 static bfd_boolean elf_xtensa_allocate_got_size 117 PARAMS ((struct elf_link_hash_entry *, PTR)); 118 static void elf_xtensa_allocate_local_got_size 119 PARAMS ((struct bfd_link_info *, asection *)); 120 static bfd_reloc_status_type elf_xtensa_do_reloc 121 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *, 122 bfd_vma, bfd_boolean, char **)); 123 static char * vsprint_msg 124 VPARAMS ((const char *, const char *, int, ...)); 125 static char *build_encoding_error_message 126 PARAMS ((xtensa_opcode, xtensa_encode_result)); 127 static bfd_reloc_status_type bfd_elf_xtensa_reloc 128 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 129 static void do_fix_for_relocatable_link 130 PARAMS ((Elf_Internal_Rela *, bfd *, asection *)); 131 static void do_fix_for_final_link 132 PARAMS ((Elf_Internal_Rela *, asection *, bfd_vma *)); 133 static bfd_vma elf_xtensa_create_plt_entry 134 PARAMS ((bfd *, bfd *, unsigned)); 135 static int elf_xtensa_combine_prop_entries 136 PARAMS ((bfd *, asection *, asection *)); 137 static bfd_boolean elf_xtensa_discard_info_for_section 138 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *, 139 asection *)); 140 141 /* Local functions to handle Xtensa configurability. */ 142 143 static void init_call_opcodes 144 PARAMS ((void)); 145 static bfd_boolean is_indirect_call_opcode 146 PARAMS ((xtensa_opcode)); 147 static bfd_boolean is_direct_call_opcode 148 PARAMS ((xtensa_opcode)); 149 static bfd_boolean is_windowed_call_opcode 150 PARAMS ((xtensa_opcode)); 151 static xtensa_opcode get_l32r_opcode 152 PARAMS ((void)); 153 static bfd_vma l32r_offset 154 PARAMS ((bfd_vma, bfd_vma)); 155 static int get_relocation_opnd 156 PARAMS ((Elf_Internal_Rela *)); 157 static xtensa_opcode get_relocation_opcode 158 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *)); 159 static bfd_boolean is_l32r_relocation 160 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *)); 161 162 /* Functions for link-time code simplifications. */ 163 164 static bfd_reloc_status_type elf_xtensa_do_asm_simplify 165 PARAMS ((bfd_byte *, bfd_vma, bfd_vma)); 166 static bfd_reloc_status_type contract_asm_expansion 167 PARAMS ((bfd_byte *, bfd_vma, Elf_Internal_Rela *)); 168 static xtensa_opcode swap_callx_for_call_opcode 169 PARAMS ((xtensa_opcode)); 170 static xtensa_opcode get_expanded_call_opcode 171 PARAMS ((bfd_byte *, int)); 172 173 /* Access to internal relocations, section contents and symbols. */ 174 175 static Elf_Internal_Rela *retrieve_internal_relocs 176 PARAMS ((bfd *, asection *, bfd_boolean)); 177 static void pin_internal_relocs 178 PARAMS ((asection *, Elf_Internal_Rela *)); 179 static void release_internal_relocs 180 PARAMS ((asection *, Elf_Internal_Rela *)); 181 static bfd_byte *retrieve_contents 182 PARAMS ((bfd *, asection *, bfd_boolean)); 183 static void pin_contents 184 PARAMS ((asection *, bfd_byte *)); 185 static void release_contents 186 PARAMS ((asection *, bfd_byte *)); 187 static Elf_Internal_Sym *retrieve_local_syms 188 PARAMS ((bfd *)); 189 190 /* Miscellaneous utility functions. */ 191 192 static asection *elf_xtensa_get_plt_section 193 PARAMS ((bfd *, int)); 194 static asection *elf_xtensa_get_gotplt_section 195 PARAMS ((bfd *, int)); 196 static asection *get_elf_r_symndx_section 197 PARAMS ((bfd *, unsigned long)); 198 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry 199 PARAMS ((bfd *, unsigned long)); 200 static bfd_vma get_elf_r_symndx_offset 201 PARAMS ((bfd *, unsigned long)); 202 static bfd_boolean pcrel_reloc_fits 203 PARAMS ((xtensa_operand, bfd_vma, bfd_vma)); 204 static bfd_boolean xtensa_is_property_section 205 PARAMS ((asection *)); 206 static bfd_boolean xtensa_is_littable_section 207 PARAMS ((asection *)); 208 static bfd_boolean is_literal_section 209 PARAMS ((asection *)); 210 static int internal_reloc_compare 211 PARAMS ((const PTR, const PTR)); 212 extern char *xtensa_get_property_section_name 213 PARAMS ((asection *, const char *)); 214 215 /* Other functions called directly by the linker. */ 216 217 typedef void (*deps_callback_t) 218 PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR)); 219 extern bfd_boolean xtensa_callback_required_dependence 220 PARAMS ((bfd *, asection *, struct bfd_link_info *, 221 deps_callback_t, PTR)); 222 223 224 typedef struct xtensa_relax_info_struct xtensa_relax_info; 225 226 227 /* Total count of PLT relocations seen during check_relocs. 228 The actual PLT code must be split into multiple sections and all 229 the sections have to be created before size_dynamic_sections, 230 where we figure out the exact number of PLT entries that will be 231 needed. It is OK if this count is an overestimate, e.g., some 232 relocations may be removed by GC. */ 233 234 static int plt_reloc_count = 0; 235 236 237 /* When this is true, relocations may have been modified to refer to 238 symbols from other input files. The per-section list of "fix" 239 records needs to be checked when resolving relocations. */ 240 241 static bfd_boolean relaxing_section = FALSE; 242 243 244 static reloc_howto_type elf_howto_table[] = 245 { 246 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont, 247 bfd_elf_xtensa_reloc, "R_XTENSA_NONE", 248 FALSE, 0x00000000, 0x00000000, FALSE), 249 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 250 bfd_elf_xtensa_reloc, "R_XTENSA_32", 251 TRUE, 0xffffffff, 0xffffffff, FALSE), 252 /* Replace a 32-bit value with a value from the runtime linker (only 253 used by linker-generated stub functions). The r_addend value is 254 special: 1 means to substitute a pointer to the runtime linker's 255 dynamic resolver function; 2 means to substitute the link map for 256 the shared object. */ 257 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont, 258 NULL, "R_XTENSA_RTLD", 259 FALSE, 0x00000000, 0x00000000, FALSE), 260 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 261 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT", 262 FALSE, 0xffffffff, 0xffffffff, FALSE), 263 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 264 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT", 265 FALSE, 0xffffffff, 0xffffffff, FALSE), 266 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 267 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE", 268 FALSE, 0xffffffff, 0xffffffff, FALSE), 269 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 270 bfd_elf_xtensa_reloc, "R_XTENSA_PLT", 271 FALSE, 0xffffffff, 0xffffffff, FALSE), 272 EMPTY_HOWTO (7), 273 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont, 274 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", 275 FALSE, 0x00000000, 0x00000000, TRUE), 276 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont, 277 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", 278 FALSE, 0x00000000, 0x00000000, TRUE), 279 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont, 280 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", 281 FALSE, 0x00000000, 0x00000000, TRUE), 282 /* Assembly auto-expansion. */ 283 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont, 284 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", 285 FALSE, 0x00000000, 0x00000000, FALSE), 286 /* Relax assembly auto-expansion. */ 287 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont, 288 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", 289 FALSE, 0x00000000, 0x00000000, TRUE), 290 EMPTY_HOWTO (13), 291 EMPTY_HOWTO (14), 292 /* GNU extension to record C++ vtable hierarchy. */ 293 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont, 294 NULL, "R_XTENSA_GNU_VTINHERIT", 295 FALSE, 0x00000000, 0x00000000, FALSE), 296 /* GNU extension to record C++ vtable member usage. */ 297 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont, 298 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY", 299 FALSE, 0x00000000, 0x00000000, FALSE) 300 }; 301 302 #ifdef DEBUG_GEN_RELOC 303 #define TRACE(str) \ 304 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str) 305 #else 306 #define TRACE(str) 307 #endif 308 309 static reloc_howto_type * 310 elf_xtensa_reloc_type_lookup (abfd, code) 311 bfd *abfd ATTRIBUTE_UNUSED; 312 bfd_reloc_code_real_type code; 313 { 314 switch (code) 315 { 316 case BFD_RELOC_NONE: 317 TRACE ("BFD_RELOC_NONE"); 318 return &elf_howto_table[(unsigned) R_XTENSA_NONE ]; 319 320 case BFD_RELOC_32: 321 TRACE ("BFD_RELOC_32"); 322 return &elf_howto_table[(unsigned) R_XTENSA_32 ]; 323 324 case BFD_RELOC_XTENSA_RTLD: 325 TRACE ("BFD_RELOC_XTENSA_RTLD"); 326 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ]; 327 328 case BFD_RELOC_XTENSA_GLOB_DAT: 329 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT"); 330 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ]; 331 332 case BFD_RELOC_XTENSA_JMP_SLOT: 333 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT"); 334 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ]; 335 336 case BFD_RELOC_XTENSA_RELATIVE: 337 TRACE ("BFD_RELOC_XTENSA_RELATIVE"); 338 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ]; 339 340 case BFD_RELOC_XTENSA_PLT: 341 TRACE ("BFD_RELOC_XTENSA_PLT"); 342 return &elf_howto_table[(unsigned) R_XTENSA_PLT ]; 343 344 case BFD_RELOC_XTENSA_OP0: 345 TRACE ("BFD_RELOC_XTENSA_OP0"); 346 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ]; 347 348 case BFD_RELOC_XTENSA_OP1: 349 TRACE ("BFD_RELOC_XTENSA_OP1"); 350 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ]; 351 352 case BFD_RELOC_XTENSA_OP2: 353 TRACE ("BFD_RELOC_XTENSA_OP2"); 354 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ]; 355 356 case BFD_RELOC_XTENSA_ASM_EXPAND: 357 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND"); 358 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ]; 359 360 case BFD_RELOC_XTENSA_ASM_SIMPLIFY: 361 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY"); 362 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ]; 363 364 case BFD_RELOC_VTABLE_INHERIT: 365 TRACE ("BFD_RELOC_VTABLE_INHERIT"); 366 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ]; 367 368 case BFD_RELOC_VTABLE_ENTRY: 369 TRACE ("BFD_RELOC_VTABLE_ENTRY"); 370 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ]; 371 372 default: 373 break; 374 } 375 376 TRACE ("Unknown"); 377 return NULL; 378 } 379 380 381 /* Given an ELF "rela" relocation, find the corresponding howto and record 382 it in the BFD internal arelent representation of the relocation. */ 383 384 static void 385 elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst) 386 bfd *abfd ATTRIBUTE_UNUSED; 387 arelent *cache_ptr; 388 Elf_Internal_Rela *dst; 389 { 390 unsigned int r_type = ELF32_R_TYPE (dst->r_info); 391 392 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max); 393 cache_ptr->howto = &elf_howto_table[r_type]; 394 } 395 396 397 /* Functions for the Xtensa ELF linker. */ 398 399 /* The name of the dynamic interpreter. This is put in the .interp 400 section. */ 401 402 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so" 403 404 /* The size in bytes of an entry in the procedure linkage table. 405 (This does _not_ include the space for the literals associated with 406 the PLT entry.) */ 407 408 #define PLT_ENTRY_SIZE 16 409 410 /* For _really_ large PLTs, we may need to alternate between literals 411 and code to keep the literals within the 256K range of the L32R 412 instructions in the code. It's unlikely that anyone would ever need 413 such a big PLT, but an arbitrary limit on the PLT size would be bad. 414 Thus, we split the PLT into chunks. Since there's very little 415 overhead (2 extra literals) for each chunk, the chunk size is kept 416 small so that the code for handling multiple chunks get used and 417 tested regularly. With 254 entries, there are 1K of literals for 418 each chunk, and that seems like a nice round number. */ 419 420 #define PLT_ENTRIES_PER_CHUNK 254 421 422 /* PLT entries are actually used as stub functions for lazy symbol 423 resolution. Once the symbol is resolved, the stub function is never 424 invoked. Note: the 32-byte frame size used here cannot be changed 425 without a corresponding change in the runtime linker. */ 426 427 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] = 428 { 429 0x6c, 0x10, 0x04, /* entry sp, 32 */ 430 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ 431 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ 432 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ 433 0x0a, 0x80, 0x00, /* jx a8 */ 434 0 /* unused */ 435 }; 436 437 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] = 438 { 439 0x36, 0x41, 0x00, /* entry sp, 32 */ 440 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ 441 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ 442 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ 443 0xa0, 0x08, 0x00, /* jx a8 */ 444 0 /* unused */ 445 }; 446 447 448 static inline bfd_boolean 449 xtensa_elf_dynamic_symbol_p (h, info) 450 struct elf_link_hash_entry *h; 451 struct bfd_link_info *info; 452 { 453 /* Check if we should do dynamic things to this symbol. The 454 "ignore_protected" argument need not be set, because Xtensa code 455 does not require special handling of STV_PROTECTED to make function 456 pointer comparisons work properly. The PLT addresses are never 457 used for function pointers. */ 458 459 return _bfd_elf_dynamic_symbol_p (h, info, 0); 460 } 461 462 463 static int 464 property_table_compare (ap, bp) 465 const PTR ap; 466 const PTR bp; 467 { 468 const property_table_entry *a = (const property_table_entry *) ap; 469 const property_table_entry *b = (const property_table_entry *) bp; 470 471 /* Check if one entry overlaps with the other; this shouldn't happen 472 except when searching for a match. */ 473 if ((b->address >= a->address && b->address < (a->address + a->size)) 474 || (a->address >= b->address && a->address < (b->address + b->size))) 475 return 0; 476 477 return (a->address - b->address); 478 } 479 480 481 /* Get the literal table or instruction table entries for the given 482 section. Sets TABLE_P and returns the number of entries. On error, 483 returns a negative value. */ 484 485 int 486 xtensa_read_table_entries (abfd, section, table_p, sec_name) 487 bfd *abfd; 488 asection *section; 489 property_table_entry **table_p; 490 const char *sec_name; 491 { 492 asection *table_section; 493 char *table_section_name; 494 bfd_size_type table_size = 0; 495 bfd_byte *table_data; 496 property_table_entry *blocks; 497 int block_count; 498 bfd_size_type num_records; 499 Elf_Internal_Rela *internal_relocs; 500 bfd_vma section_addr; 501 502 table_section_name = 503 xtensa_get_property_section_name (section, sec_name); 504 table_section = bfd_get_section_by_name (abfd, table_section_name); 505 free (table_section_name); 506 if (table_section != NULL) 507 table_size = (table_section->_cooked_size 508 ? table_section->_cooked_size : table_section->_raw_size); 509 510 if (table_size == 0) 511 { 512 *table_p = NULL; 513 return 0; 514 } 515 516 num_records = table_size / 8; 517 table_data = retrieve_contents (abfd, table_section, TRUE); 518 blocks = (property_table_entry *) 519 bfd_malloc (num_records * sizeof (property_table_entry)); 520 block_count = 0; 521 522 section_addr = section->output_section->vma + section->output_offset; 523 524 /* If the file has not yet been relocated, process the relocations 525 and sort out the table entries that apply to the specified section. */ 526 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE); 527 if (internal_relocs && !table_section->reloc_done) 528 { 529 unsigned i; 530 531 for (i = 0; i < table_section->reloc_count; i++) 532 { 533 Elf_Internal_Rela *rel = &internal_relocs[i]; 534 unsigned long r_symndx; 535 536 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE) 537 continue; 538 539 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32); 540 r_symndx = ELF32_R_SYM (rel->r_info); 541 542 if (get_elf_r_symndx_section (abfd, r_symndx) == section) 543 { 544 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx); 545 blocks[block_count].address = 546 (section_addr + sym_off + rel->r_addend 547 + bfd_get_32 (abfd, table_data + rel->r_offset)); 548 blocks[block_count].size = 549 bfd_get_32 (abfd, table_data + rel->r_offset + 4); 550 block_count++; 551 } 552 } 553 } 554 else 555 { 556 /* The file has already been relocated and the addresses are 557 already in the table. */ 558 bfd_vma off; 559 560 for (off = 0; off < table_size; off += 8) 561 { 562 bfd_vma address = bfd_get_32 (abfd, table_data + off); 563 564 if (address >= section_addr 565 && address < ( section_addr + section->_raw_size)) 566 { 567 blocks[block_count].address = address; 568 blocks[block_count].size = 569 bfd_get_32 (abfd, table_data + off + 4); 570 block_count++; 571 } 572 } 573 } 574 575 release_contents (table_section, table_data); 576 release_internal_relocs (table_section, internal_relocs); 577 578 if (block_count > 0) 579 { 580 /* Now sort them into address order for easy reference. */ 581 qsort (blocks, block_count, sizeof (property_table_entry), 582 property_table_compare); 583 } 584 585 *table_p = blocks; 586 return block_count; 587 } 588 589 590 static bfd_boolean 591 elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr) 592 property_table_entry *lit_table; 593 int lit_table_size; 594 bfd_vma addr; 595 { 596 property_table_entry entry; 597 598 if (lit_table_size == 0) 599 return FALSE; 600 601 entry.address = addr; 602 entry.size = 1; 603 604 if (bsearch (&entry, lit_table, lit_table_size, 605 sizeof (property_table_entry), property_table_compare)) 606 return TRUE; 607 608 return FALSE; 609 } 610 611 612 /* Look through the relocs for a section during the first phase, and 613 calculate needed space in the dynamic reloc sections. */ 614 615 static bfd_boolean 616 elf_xtensa_check_relocs (abfd, info, sec, relocs) 617 bfd *abfd; 618 struct bfd_link_info *info; 619 asection *sec; 620 const Elf_Internal_Rela *relocs; 621 { 622 Elf_Internal_Shdr *symtab_hdr; 623 struct elf_link_hash_entry **sym_hashes; 624 const Elf_Internal_Rela *rel; 625 const Elf_Internal_Rela *rel_end; 626 627 if (info->relocatable) 628 return TRUE; 629 630 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 631 sym_hashes = elf_sym_hashes (abfd); 632 633 rel_end = relocs + sec->reloc_count; 634 for (rel = relocs; rel < rel_end; rel++) 635 { 636 unsigned int r_type; 637 unsigned long r_symndx; 638 struct elf_link_hash_entry *h; 639 640 r_symndx = ELF32_R_SYM (rel->r_info); 641 r_type = ELF32_R_TYPE (rel->r_info); 642 643 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 644 { 645 (*_bfd_error_handler) (_("%s: bad symbol index: %d"), 646 bfd_archive_filename (abfd), 647 r_symndx); 648 return FALSE; 649 } 650 651 if (r_symndx < symtab_hdr->sh_info) 652 h = NULL; 653 else 654 { 655 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 656 while (h->root.type == bfd_link_hash_indirect 657 || h->root.type == bfd_link_hash_warning) 658 h = (struct elf_link_hash_entry *) h->root.u.i.link; 659 } 660 661 switch (r_type) 662 { 663 case R_XTENSA_32: 664 if (h == NULL) 665 goto local_literal; 666 667 if ((sec->flags & SEC_ALLOC) != 0) 668 { 669 if (h->got.refcount <= 0) 670 h->got.refcount = 1; 671 else 672 h->got.refcount += 1; 673 } 674 break; 675 676 case R_XTENSA_PLT: 677 /* If this relocation is against a local symbol, then it's 678 exactly the same as a normal local GOT entry. */ 679 if (h == NULL) 680 goto local_literal; 681 682 if ((sec->flags & SEC_ALLOC) != 0) 683 { 684 if (h->plt.refcount <= 0) 685 { 686 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 687 h->plt.refcount = 1; 688 } 689 else 690 h->plt.refcount += 1; 691 692 /* Keep track of the total PLT relocation count even if we 693 don't yet know whether the dynamic sections will be 694 created. */ 695 plt_reloc_count += 1; 696 697 if (elf_hash_table (info)->dynamic_sections_created) 698 { 699 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj, 700 plt_reloc_count)) 701 return FALSE; 702 } 703 } 704 break; 705 706 local_literal: 707 if ((sec->flags & SEC_ALLOC) != 0) 708 { 709 bfd_signed_vma *local_got_refcounts; 710 711 /* This is a global offset table entry for a local symbol. */ 712 local_got_refcounts = elf_local_got_refcounts (abfd); 713 if (local_got_refcounts == NULL) 714 { 715 bfd_size_type size; 716 717 size = symtab_hdr->sh_info; 718 size *= sizeof (bfd_signed_vma); 719 local_got_refcounts = ((bfd_signed_vma *) 720 bfd_zalloc (abfd, size)); 721 if (local_got_refcounts == NULL) 722 return FALSE; 723 elf_local_got_refcounts (abfd) = local_got_refcounts; 724 } 725 local_got_refcounts[r_symndx] += 1; 726 } 727 break; 728 729 case R_XTENSA_OP0: 730 case R_XTENSA_OP1: 731 case R_XTENSA_OP2: 732 case R_XTENSA_ASM_EXPAND: 733 case R_XTENSA_ASM_SIMPLIFY: 734 /* Nothing to do for these. */ 735 break; 736 737 case R_XTENSA_GNU_VTINHERIT: 738 /* This relocation describes the C++ object vtable hierarchy. 739 Reconstruct it for later use during GC. */ 740 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 741 return FALSE; 742 break; 743 744 case R_XTENSA_GNU_VTENTRY: 745 /* This relocation describes which C++ vtable entries are actually 746 used. Record for later use during GC. */ 747 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 748 return FALSE; 749 break; 750 751 default: 752 break; 753 } 754 } 755 756 return TRUE; 757 } 758 759 760 static void 761 elf_xtensa_hide_symbol (info, h, force_local) 762 struct bfd_link_info *info; 763 struct elf_link_hash_entry *h; 764 bfd_boolean force_local; 765 { 766 /* For a shared link, move the plt refcount to the got refcount to leave 767 space for RELATIVE relocs. */ 768 elf_xtensa_make_sym_local (info, h); 769 770 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 771 } 772 773 774 /* Return the section that should be marked against GC for a given 775 relocation. */ 776 777 static asection * 778 elf_xtensa_gc_mark_hook (sec, info, rel, h, sym) 779 asection *sec; 780 struct bfd_link_info *info ATTRIBUTE_UNUSED; 781 Elf_Internal_Rela *rel; 782 struct elf_link_hash_entry *h; 783 Elf_Internal_Sym *sym; 784 { 785 if (h != NULL) 786 { 787 switch (ELF32_R_TYPE (rel->r_info)) 788 { 789 case R_XTENSA_GNU_VTINHERIT: 790 case R_XTENSA_GNU_VTENTRY: 791 break; 792 793 default: 794 switch (h->root.type) 795 { 796 case bfd_link_hash_defined: 797 case bfd_link_hash_defweak: 798 return h->root.u.def.section; 799 800 case bfd_link_hash_common: 801 return h->root.u.c.p->section; 802 803 default: 804 break; 805 } 806 } 807 } 808 else 809 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 810 811 return NULL; 812 } 813 814 /* Update the GOT & PLT entry reference counts 815 for the section being removed. */ 816 817 static bfd_boolean 818 elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs) 819 bfd *abfd; 820 struct bfd_link_info *info ATTRIBUTE_UNUSED; 821 asection *sec; 822 const Elf_Internal_Rela *relocs; 823 { 824 Elf_Internal_Shdr *symtab_hdr; 825 struct elf_link_hash_entry **sym_hashes; 826 bfd_signed_vma *local_got_refcounts; 827 const Elf_Internal_Rela *rel, *relend; 828 829 if ((sec->flags & SEC_ALLOC) == 0) 830 return TRUE; 831 832 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 833 sym_hashes = elf_sym_hashes (abfd); 834 local_got_refcounts = elf_local_got_refcounts (abfd); 835 836 relend = relocs + sec->reloc_count; 837 for (rel = relocs; rel < relend; rel++) 838 { 839 unsigned long r_symndx; 840 unsigned int r_type; 841 struct elf_link_hash_entry *h = NULL; 842 843 r_symndx = ELF32_R_SYM (rel->r_info); 844 if (r_symndx >= symtab_hdr->sh_info) 845 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 846 847 r_type = ELF32_R_TYPE (rel->r_info); 848 switch (r_type) 849 { 850 case R_XTENSA_32: 851 if (h == NULL) 852 goto local_literal; 853 if (h->got.refcount > 0) 854 h->got.refcount--; 855 break; 856 857 case R_XTENSA_PLT: 858 if (h == NULL) 859 goto local_literal; 860 if (h->plt.refcount > 0) 861 h->plt.refcount--; 862 break; 863 864 local_literal: 865 if (local_got_refcounts[r_symndx] > 0) 866 local_got_refcounts[r_symndx] -= 1; 867 break; 868 869 default: 870 break; 871 } 872 } 873 874 return TRUE; 875 } 876 877 878 /* Create all the dynamic sections. */ 879 880 static bfd_boolean 881 elf_xtensa_create_dynamic_sections (dynobj, info) 882 bfd *dynobj; 883 struct bfd_link_info *info; 884 { 885 flagword flags, noalloc_flags; 886 asection *s; 887 888 /* First do all the standard stuff. */ 889 if (! _bfd_elf_create_dynamic_sections (dynobj, info)) 890 return FALSE; 891 892 /* Create any extra PLT sections in case check_relocs has already 893 been called on all the non-dynamic input files. */ 894 if (!add_extra_plt_sections (dynobj, plt_reloc_count)) 895 return FALSE; 896 897 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY 898 | SEC_LINKER_CREATED | SEC_READONLY); 899 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD; 900 901 /* Mark the ".got.plt" section READONLY. */ 902 s = bfd_get_section_by_name (dynobj, ".got.plt"); 903 if (s == NULL 904 || ! bfd_set_section_flags (dynobj, s, flags)) 905 return FALSE; 906 907 /* Create ".rela.got". */ 908 s = bfd_make_section (dynobj, ".rela.got"); 909 if (s == NULL 910 || ! bfd_set_section_flags (dynobj, s, flags) 911 || ! bfd_set_section_alignment (dynobj, s, 2)) 912 return FALSE; 913 914 /* Create ".got.loc" (literal tables for use by dynamic linker). */ 915 s = bfd_make_section (dynobj, ".got.loc"); 916 if (s == NULL 917 || ! bfd_set_section_flags (dynobj, s, flags) 918 || ! bfd_set_section_alignment (dynobj, s, 2)) 919 return FALSE; 920 921 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */ 922 s = bfd_make_section (dynobj, ".xt.lit.plt"); 923 if (s == NULL 924 || ! bfd_set_section_flags (dynobj, s, noalloc_flags) 925 || ! bfd_set_section_alignment (dynobj, s, 2)) 926 return FALSE; 927 928 return TRUE; 929 } 930 931 932 static bfd_boolean 933 add_extra_plt_sections (dynobj, count) 934 bfd *dynobj; 935 int count; 936 { 937 int chunk; 938 939 /* Iterate over all chunks except 0 which uses the standard ".plt" and 940 ".got.plt" sections. */ 941 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--) 942 { 943 char *sname; 944 flagword flags; 945 asection *s; 946 947 /* Stop when we find a section has already been created. */ 948 if (elf_xtensa_get_plt_section (dynobj, chunk)) 949 break; 950 951 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 952 | SEC_LINKER_CREATED | SEC_READONLY); 953 954 sname = (char *) bfd_malloc (10); 955 sprintf (sname, ".plt.%u", chunk); 956 s = bfd_make_section (dynobj, sname); 957 if (s == NULL 958 || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE) 959 || ! bfd_set_section_alignment (dynobj, s, 2)) 960 return FALSE; 961 962 sname = (char *) bfd_malloc (14); 963 sprintf (sname, ".got.plt.%u", chunk); 964 s = bfd_make_section (dynobj, sname); 965 if (s == NULL 966 || ! bfd_set_section_flags (dynobj, s, flags) 967 || ! bfd_set_section_alignment (dynobj, s, 2)) 968 return FALSE; 969 } 970 971 return TRUE; 972 } 973 974 975 /* Adjust a symbol defined by a dynamic object and referenced by a 976 regular object. The current definition is in some section of the 977 dynamic object, but we're not including those sections. We have to 978 change the definition to something the rest of the link can 979 understand. */ 980 981 static bfd_boolean 982 elf_xtensa_adjust_dynamic_symbol (info, h) 983 struct bfd_link_info *info ATTRIBUTE_UNUSED; 984 struct elf_link_hash_entry *h; 985 { 986 /* If this is a weak symbol, and there is a real definition, the 987 processor independent code will have arranged for us to see the 988 real definition first, and we can just use the same value. */ 989 if (h->weakdef != NULL) 990 { 991 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 992 || h->weakdef->root.type == bfd_link_hash_defweak); 993 h->root.u.def.section = h->weakdef->root.u.def.section; 994 h->root.u.def.value = h->weakdef->root.u.def.value; 995 return TRUE; 996 } 997 998 /* This is a reference to a symbol defined by a dynamic object. The 999 reference must go through the GOT, so there's no need for COPY relocs, 1000 .dynbss, etc. */ 1001 1002 return TRUE; 1003 } 1004 1005 1006 static void 1007 elf_xtensa_make_sym_local (info, h) 1008 struct bfd_link_info *info; 1009 struct elf_link_hash_entry *h; 1010 { 1011 if (info->shared) 1012 { 1013 if (h->plt.refcount > 0) 1014 { 1015 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */ 1016 if (h->got.refcount < 0) 1017 h->got.refcount = 0; 1018 h->got.refcount += h->plt.refcount; 1019 h->plt.refcount = 0; 1020 } 1021 } 1022 else 1023 { 1024 /* Don't need any dynamic relocations at all. */ 1025 h->plt.refcount = 0; 1026 h->got.refcount = 0; 1027 } 1028 } 1029 1030 1031 static bfd_boolean 1032 elf_xtensa_fix_refcounts (h, arg) 1033 struct elf_link_hash_entry *h; 1034 PTR arg; 1035 { 1036 struct bfd_link_info *info = (struct bfd_link_info *) arg; 1037 1038 if (h->root.type == bfd_link_hash_warning) 1039 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1040 1041 if (! xtensa_elf_dynamic_symbol_p (h, info)) 1042 elf_xtensa_make_sym_local (info, h); 1043 1044 return TRUE; 1045 } 1046 1047 1048 static bfd_boolean 1049 elf_xtensa_allocate_plt_size (h, arg) 1050 struct elf_link_hash_entry *h; 1051 PTR arg; 1052 { 1053 asection *srelplt = (asection *) arg; 1054 1055 if (h->root.type == bfd_link_hash_warning) 1056 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1057 1058 if (h->plt.refcount > 0) 1059 srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela)); 1060 1061 return TRUE; 1062 } 1063 1064 1065 static bfd_boolean 1066 elf_xtensa_allocate_got_size (h, arg) 1067 struct elf_link_hash_entry *h; 1068 PTR arg; 1069 { 1070 asection *srelgot = (asection *) arg; 1071 1072 if (h->root.type == bfd_link_hash_warning) 1073 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1074 1075 if (h->got.refcount > 0) 1076 srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela)); 1077 1078 return TRUE; 1079 } 1080 1081 1082 static void 1083 elf_xtensa_allocate_local_got_size (info, srelgot) 1084 struct bfd_link_info *info; 1085 asection *srelgot; 1086 { 1087 bfd *i; 1088 1089 for (i = info->input_bfds; i; i = i->link_next) 1090 { 1091 bfd_signed_vma *local_got_refcounts; 1092 bfd_size_type j, cnt; 1093 Elf_Internal_Shdr *symtab_hdr; 1094 1095 local_got_refcounts = elf_local_got_refcounts (i); 1096 if (!local_got_refcounts) 1097 continue; 1098 1099 symtab_hdr = &elf_tdata (i)->symtab_hdr; 1100 cnt = symtab_hdr->sh_info; 1101 1102 for (j = 0; j < cnt; ++j) 1103 { 1104 if (local_got_refcounts[j] > 0) 1105 srelgot->_raw_size += (local_got_refcounts[j] 1106 * sizeof (Elf32_External_Rela)); 1107 } 1108 } 1109 } 1110 1111 1112 /* Set the sizes of the dynamic sections. */ 1113 1114 static bfd_boolean 1115 elf_xtensa_size_dynamic_sections (output_bfd, info) 1116 bfd *output_bfd ATTRIBUTE_UNUSED; 1117 struct bfd_link_info *info; 1118 { 1119 bfd *dynobj, *abfd; 1120 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc; 1121 bfd_boolean relplt, relgot; 1122 int plt_entries, plt_chunks, chunk; 1123 1124 plt_entries = 0; 1125 plt_chunks = 0; 1126 srelgot = 0; 1127 1128 dynobj = elf_hash_table (info)->dynobj; 1129 if (dynobj == NULL) 1130 abort (); 1131 1132 if (elf_hash_table (info)->dynamic_sections_created) 1133 { 1134 /* Set the contents of the .interp section to the interpreter. */ 1135 if (info->executable) 1136 { 1137 s = bfd_get_section_by_name (dynobj, ".interp"); 1138 if (s == NULL) 1139 abort (); 1140 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1141 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1142 } 1143 1144 /* Allocate room for one word in ".got". */ 1145 s = bfd_get_section_by_name (dynobj, ".got"); 1146 if (s == NULL) 1147 abort (); 1148 s->_raw_size = 4; 1149 1150 /* Adjust refcounts for symbols that we now know are not "dynamic". */ 1151 elf_link_hash_traverse (elf_hash_table (info), 1152 elf_xtensa_fix_refcounts, 1153 (PTR) info); 1154 1155 /* Allocate space in ".rela.got" for literals that reference 1156 global symbols. */ 1157 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 1158 if (srelgot == NULL) 1159 abort (); 1160 elf_link_hash_traverse (elf_hash_table (info), 1161 elf_xtensa_allocate_got_size, 1162 (PTR) srelgot); 1163 1164 /* If we are generating a shared object, we also need space in 1165 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that 1166 reference local symbols. */ 1167 if (info->shared) 1168 elf_xtensa_allocate_local_got_size (info, srelgot); 1169 1170 /* Allocate space in ".rela.plt" for literals that have PLT entries. */ 1171 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 1172 if (srelplt == NULL) 1173 abort (); 1174 elf_link_hash_traverse (elf_hash_table (info), 1175 elf_xtensa_allocate_plt_size, 1176 (PTR) srelplt); 1177 1178 /* Allocate space in ".plt" to match the size of ".rela.plt". For 1179 each PLT entry, we need the PLT code plus a 4-byte literal. 1180 For each chunk of ".plt", we also need two more 4-byte 1181 literals, two corresponding entries in ".rela.got", and an 1182 8-byte entry in ".xt.lit.plt". */ 1183 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt"); 1184 if (spltlittbl == NULL) 1185 abort (); 1186 1187 plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela); 1188 plt_chunks = 1189 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK; 1190 1191 /* Iterate over all the PLT chunks, including any extra sections 1192 created earlier because the initial count of PLT relocations 1193 was an overestimate. */ 1194 for (chunk = 0; 1195 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL; 1196 chunk++) 1197 { 1198 int chunk_entries; 1199 1200 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk); 1201 if (sgotplt == NULL) 1202 abort (); 1203 1204 if (chunk < plt_chunks - 1) 1205 chunk_entries = PLT_ENTRIES_PER_CHUNK; 1206 else if (chunk == plt_chunks - 1) 1207 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK); 1208 else 1209 chunk_entries = 0; 1210 1211 if (chunk_entries != 0) 1212 { 1213 sgotplt->_raw_size = 4 * (chunk_entries + 2); 1214 splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries; 1215 srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela); 1216 spltlittbl->_raw_size += 8; 1217 } 1218 else 1219 { 1220 sgotplt->_raw_size = 0; 1221 splt->_raw_size = 0; 1222 } 1223 } 1224 1225 /* Allocate space in ".got.loc" to match the total size of all the 1226 literal tables. */ 1227 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc"); 1228 if (sgotloc == NULL) 1229 abort (); 1230 sgotloc->_raw_size = spltlittbl->_raw_size; 1231 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next) 1232 { 1233 if (abfd->flags & DYNAMIC) 1234 continue; 1235 for (s = abfd->sections; s != NULL; s = s->next) 1236 { 1237 if (! elf_discarded_section (s) 1238 && xtensa_is_littable_section (s) 1239 && s != spltlittbl) 1240 sgotloc->_raw_size += s->_raw_size; 1241 } 1242 } 1243 } 1244 1245 /* Allocate memory for dynamic sections. */ 1246 relplt = FALSE; 1247 relgot = FALSE; 1248 for (s = dynobj->sections; s != NULL; s = s->next) 1249 { 1250 const char *name; 1251 bfd_boolean strip; 1252 1253 if ((s->flags & SEC_LINKER_CREATED) == 0) 1254 continue; 1255 1256 /* It's OK to base decisions on the section name, because none 1257 of the dynobj section names depend upon the input files. */ 1258 name = bfd_get_section_name (dynobj, s); 1259 1260 strip = FALSE; 1261 1262 if (strncmp (name, ".rela", 5) == 0) 1263 { 1264 if (strcmp (name, ".rela.plt") == 0) 1265 relplt = TRUE; 1266 else if (strcmp (name, ".rela.got") == 0) 1267 relgot = TRUE; 1268 1269 /* We use the reloc_count field as a counter if we need 1270 to copy relocs into the output file. */ 1271 s->reloc_count = 0; 1272 } 1273 else if (strncmp (name, ".plt.", 5) == 0 1274 || strncmp (name, ".got.plt.", 9) == 0) 1275 { 1276 if (s->_raw_size == 0) 1277 { 1278 /* If we don't need this section, strip it from the output 1279 file. We must create the ".plt*" and ".got.plt*" 1280 sections in create_dynamic_sections and/or check_relocs 1281 based on a conservative estimate of the PLT relocation 1282 count, because the sections must be created before the 1283 linker maps input sections to output sections. The 1284 linker does that before size_dynamic_sections, where we 1285 compute the exact size of the PLT, so there may be more 1286 of these sections than are actually needed. */ 1287 strip = TRUE; 1288 } 1289 } 1290 else if (strcmp (name, ".got") != 0 1291 && strcmp (name, ".plt") != 0 1292 && strcmp (name, ".got.plt") != 0 1293 && strcmp (name, ".xt.lit.plt") != 0 1294 && strcmp (name, ".got.loc") != 0) 1295 { 1296 /* It's not one of our sections, so don't allocate space. */ 1297 continue; 1298 } 1299 1300 if (strip) 1301 _bfd_strip_section_from_output (info, s); 1302 else 1303 { 1304 /* Allocate memory for the section contents. */ 1305 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1306 if (s->contents == NULL && s->_raw_size != 0) 1307 return FALSE; 1308 } 1309 } 1310 1311 if (elf_hash_table (info)->dynamic_sections_created) 1312 { 1313 /* Add the special XTENSA_RTLD relocations now. The offsets won't be 1314 known until finish_dynamic_sections, but we need to get the relocs 1315 in place before they are sorted. */ 1316 if (srelgot == NULL) 1317 abort (); 1318 for (chunk = 0; chunk < plt_chunks; chunk++) 1319 { 1320 Elf_Internal_Rela irela; 1321 bfd_byte *loc; 1322 1323 irela.r_offset = 0; 1324 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD); 1325 irela.r_addend = 0; 1326 1327 loc = (srelgot->contents 1328 + srelgot->reloc_count * sizeof (Elf32_External_Rela)); 1329 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc); 1330 bfd_elf32_swap_reloca_out (output_bfd, &irela, 1331 loc + sizeof (Elf32_External_Rela)); 1332 srelgot->reloc_count += 2; 1333 } 1334 1335 /* Add some entries to the .dynamic section. We fill in the 1336 values later, in elf_xtensa_finish_dynamic_sections, but we 1337 must add the entries now so that we get the correct size for 1338 the .dynamic section. The DT_DEBUG entry is filled in by the 1339 dynamic linker and used by the debugger. */ 1340 #define add_dynamic_entry(TAG, VAL) \ 1341 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1342 1343 if (! info->shared) 1344 { 1345 if (!add_dynamic_entry (DT_DEBUG, 0)) 1346 return FALSE; 1347 } 1348 1349 if (relplt) 1350 { 1351 if (!add_dynamic_entry (DT_PLTGOT, 0) 1352 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1353 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1354 || !add_dynamic_entry (DT_JMPREL, 0)) 1355 return FALSE; 1356 } 1357 1358 if (relgot) 1359 { 1360 if (!add_dynamic_entry (DT_RELA, 0) 1361 || !add_dynamic_entry (DT_RELASZ, 0) 1362 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 1363 return FALSE; 1364 } 1365 1366 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0) 1367 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0)) 1368 return FALSE; 1369 } 1370 #undef add_dynamic_entry 1371 1372 return TRUE; 1373 } 1374 1375 1376 /* Remove any PT_LOAD segments with no allocated sections. Prior to 1377 binutils 2.13, this function used to remove the non-SEC_ALLOC 1378 sections from PT_LOAD segments, but that task has now been moved 1379 into elf.c. We still need this function to remove any empty 1380 segments that result, but there's nothing Xtensa-specific about 1381 this and it probably ought to be moved into elf.c as well. */ 1382 1383 static bfd_boolean 1384 elf_xtensa_modify_segment_map (abfd, info) 1385 bfd *abfd; 1386 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1387 { 1388 struct elf_segment_map **m_p; 1389 1390 m_p = &elf_tdata (abfd)->segment_map; 1391 while (*m_p != NULL) 1392 { 1393 if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0) 1394 *m_p = (*m_p)->next; 1395 else 1396 m_p = &(*m_p)->next; 1397 } 1398 return TRUE; 1399 } 1400 1401 1402 /* Perform the specified relocation. The instruction at (contents + address) 1403 is modified to set one operand to represent the value in "relocation". The 1404 operand position is determined by the relocation type recorded in the 1405 howto. */ 1406 1407 #define CALL_SEGMENT_BITS (30) 1408 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS) 1409 1410 static bfd_reloc_status_type 1411 elf_xtensa_do_reloc (howto, abfd, input_section, relocation, 1412 contents, address, is_weak_undef, error_message) 1413 reloc_howto_type *howto; 1414 bfd *abfd; 1415 asection *input_section; 1416 bfd_vma relocation; 1417 bfd_byte *contents; 1418 bfd_vma address; 1419 bfd_boolean is_weak_undef; 1420 char **error_message; 1421 { 1422 xtensa_opcode opcode; 1423 xtensa_operand operand; 1424 xtensa_encode_result encode_result; 1425 xtensa_isa isa = xtensa_default_isa; 1426 xtensa_insnbuf ibuff; 1427 bfd_vma self_address; 1428 int opnd; 1429 uint32 newval; 1430 1431 switch (howto->type) 1432 { 1433 case R_XTENSA_NONE: 1434 return bfd_reloc_ok; 1435 1436 case R_XTENSA_ASM_EXPAND: 1437 if (!is_weak_undef) 1438 { 1439 /* Check for windowed CALL across a 1GB boundary. */ 1440 xtensa_opcode opcode = 1441 get_expanded_call_opcode (contents + address, 1442 input_section->_raw_size - address); 1443 if (is_windowed_call_opcode (opcode)) 1444 { 1445 self_address = (input_section->output_section->vma 1446 + input_section->output_offset 1447 + address); 1448 if ((self_address >> CALL_SEGMENT_BITS) != 1449 (relocation >> CALL_SEGMENT_BITS)) 1450 { 1451 *error_message = "windowed longcall crosses 1GB boundary; " 1452 "return may fail"; 1453 return bfd_reloc_dangerous; 1454 } 1455 } 1456 } 1457 return bfd_reloc_ok; 1458 1459 case R_XTENSA_ASM_SIMPLIFY: 1460 { 1461 /* Convert the L32R/CALLX to CALL. */ 1462 bfd_reloc_status_type retval = 1463 elf_xtensa_do_asm_simplify (contents, address, 1464 input_section->_raw_size); 1465 if (retval != bfd_reloc_ok) 1466 return retval; 1467 1468 /* The CALL needs to be relocated. Continue below for that part. */ 1469 address += 3; 1470 howto = &elf_howto_table[(unsigned) R_XTENSA_OP0 ]; 1471 } 1472 break; 1473 1474 case R_XTENSA_32: 1475 case R_XTENSA_PLT: 1476 { 1477 bfd_vma x; 1478 x = bfd_get_32 (abfd, contents + address); 1479 x = x + relocation; 1480 bfd_put_32 (abfd, x, contents + address); 1481 } 1482 return bfd_reloc_ok; 1483 } 1484 1485 /* Read the instruction into a buffer and decode the opcode. */ 1486 ibuff = xtensa_insnbuf_alloc (isa); 1487 xtensa_insnbuf_from_chars (isa, ibuff, contents + address); 1488 opcode = xtensa_decode_insn (isa, ibuff); 1489 1490 /* Determine which operand is being relocated. */ 1491 if (opcode == XTENSA_UNDEFINED) 1492 { 1493 *error_message = "cannot decode instruction"; 1494 return bfd_reloc_dangerous; 1495 } 1496 1497 if (howto->type < R_XTENSA_OP0 || howto->type > R_XTENSA_OP2) 1498 { 1499 *error_message = "unexpected relocation"; 1500 return bfd_reloc_dangerous; 1501 } 1502 1503 opnd = howto->type - R_XTENSA_OP0; 1504 1505 /* Calculate the PC address for this instruction. */ 1506 if (!howto->pc_relative) 1507 { 1508 *error_message = "expected PC-relative relocation"; 1509 return bfd_reloc_dangerous; 1510 } 1511 1512 self_address = (input_section->output_section->vma 1513 + input_section->output_offset 1514 + address); 1515 1516 /* Apply the relocation. */ 1517 operand = xtensa_get_operand (isa, opcode, opnd); 1518 newval = xtensa_operand_do_reloc (operand, relocation, self_address); 1519 encode_result = xtensa_operand_encode (operand, &newval); 1520 xtensa_operand_set_field (operand, ibuff, newval); 1521 1522 /* Write the modified instruction back out of the buffer. */ 1523 xtensa_insnbuf_to_chars (isa, ibuff, contents + address); 1524 free (ibuff); 1525 1526 if (encode_result != xtensa_encode_result_ok) 1527 { 1528 char *message = build_encoding_error_message (opcode, encode_result); 1529 *error_message = message; 1530 return bfd_reloc_dangerous; 1531 } 1532 1533 /* Final check for call. */ 1534 if (is_direct_call_opcode (opcode) 1535 && is_windowed_call_opcode (opcode)) 1536 { 1537 if ((self_address >> CALL_SEGMENT_BITS) != 1538 (relocation >> CALL_SEGMENT_BITS)) 1539 { 1540 *error_message = "windowed call crosses 1GB boundary; " 1541 "return may fail"; 1542 return bfd_reloc_dangerous; 1543 } 1544 } 1545 1546 return bfd_reloc_ok; 1547 } 1548 1549 1550 static char * 1551 vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...)) 1552 { 1553 /* To reduce the size of the memory leak, 1554 we only use a single message buffer. */ 1555 static bfd_size_type alloc_size = 0; 1556 static char *message = NULL; 1557 bfd_size_type orig_len, len = 0; 1558 bfd_boolean is_append; 1559 1560 VA_OPEN (ap, arglen); 1561 VA_FIXEDARG (ap, const char *, origmsg); 1562 1563 is_append = (origmsg == message); 1564 1565 orig_len = strlen (origmsg); 1566 len = orig_len + strlen (fmt) + arglen + 20; 1567 if (len > alloc_size) 1568 { 1569 message = (char *) bfd_realloc (message, len); 1570 alloc_size = len; 1571 } 1572 if (!is_append) 1573 memcpy (message, origmsg, orig_len); 1574 vsprintf (message + orig_len, fmt, ap); 1575 VA_CLOSE (ap); 1576 return message; 1577 } 1578 1579 1580 static char * 1581 build_encoding_error_message (opcode, encode_result) 1582 xtensa_opcode opcode; 1583 xtensa_encode_result encode_result; 1584 { 1585 const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode); 1586 const char *msg = NULL; 1587 1588 switch (encode_result) 1589 { 1590 case xtensa_encode_result_ok: 1591 msg = "unexpected valid encoding"; 1592 break; 1593 case xtensa_encode_result_align: 1594 msg = "misaligned encoding"; 1595 break; 1596 case xtensa_encode_result_not_in_table: 1597 msg = "encoding not in lookup table"; 1598 break; 1599 case xtensa_encode_result_too_low: 1600 msg = "encoding out of range: too low"; 1601 break; 1602 case xtensa_encode_result_too_high: 1603 msg = "encoding out of range: too high"; 1604 break; 1605 case xtensa_encode_result_not_ok: 1606 default: 1607 msg = "could not encode"; 1608 break; 1609 } 1610 1611 if (is_direct_call_opcode (opcode) 1612 && (encode_result == xtensa_encode_result_too_low 1613 || encode_result == xtensa_encode_result_too_high)) 1614 1615 msg = "direct call out of range"; 1616 1617 else if (opcode == get_l32r_opcode ()) 1618 { 1619 /* L32Rs have the strange interaction with encoding in that they 1620 have an unsigned immediate field, so libisa returns "too high" 1621 when the absolute value is out of range and never returns "too 1622 low", but I leave the "too low" message in case anything 1623 changes. */ 1624 if (encode_result == xtensa_encode_result_too_low) 1625 msg = "literal out of range"; 1626 else if (encode_result == xtensa_encode_result_too_high) 1627 msg = "literal placed after use"; 1628 } 1629 1630 return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg); 1631 } 1632 1633 1634 /* This function is registered as the "special_function" in the 1635 Xtensa howto for handling simplify operations. 1636 bfd_perform_relocation / bfd_install_relocation use it to 1637 perform (install) the specified relocation. Since this replaces the code 1638 in bfd_perform_relocation, it is basically an Xtensa-specific, 1639 stripped-down version of bfd_perform_relocation. */ 1640 1641 static bfd_reloc_status_type 1642 bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section, 1643 output_bfd, error_message) 1644 bfd *abfd; 1645 arelent *reloc_entry; 1646 asymbol *symbol; 1647 PTR data; 1648 asection *input_section; 1649 bfd *output_bfd; 1650 char **error_message; 1651 { 1652 bfd_vma relocation; 1653 bfd_reloc_status_type flag; 1654 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 1655 bfd_vma output_base = 0; 1656 reloc_howto_type *howto = reloc_entry->howto; 1657 asection *reloc_target_output_section; 1658 bfd_boolean is_weak_undef; 1659 1660 /* ELF relocs are against symbols. If we are producing relocatable 1661 output, and the reloc is against an external symbol, the resulting 1662 reloc will also be against the same symbol. In such a case, we 1663 don't want to change anything about the way the reloc is handled, 1664 since it will all be done at final link time. This test is similar 1665 to what bfd_elf_generic_reloc does except that it lets relocs with 1666 howto->partial_inplace go through even if the addend is non-zero. 1667 (The real problem is that partial_inplace is set for XTENSA_32 1668 relocs to begin with, but that's a long story and there's little we 1669 can do about it now....) */ 1670 1671 if (output_bfd != (bfd *) NULL 1672 && (symbol->flags & BSF_SECTION_SYM) == 0) 1673 { 1674 reloc_entry->address += input_section->output_offset; 1675 return bfd_reloc_ok; 1676 } 1677 1678 /* Is the address of the relocation really within the section? */ 1679 if (reloc_entry->address > (input_section->_cooked_size 1680 / bfd_octets_per_byte (abfd))) 1681 return bfd_reloc_outofrange; 1682 1683 /* Work out which section the relocation is targeted at and the 1684 initial relocation command value. */ 1685 1686 /* Get symbol value. (Common symbols are special.) */ 1687 if (bfd_is_com_section (symbol->section)) 1688 relocation = 0; 1689 else 1690 relocation = symbol->value; 1691 1692 reloc_target_output_section = symbol->section->output_section; 1693 1694 /* Convert input-section-relative symbol value to absolute. */ 1695 if ((output_bfd && !howto->partial_inplace) 1696 || reloc_target_output_section == NULL) 1697 output_base = 0; 1698 else 1699 output_base = reloc_target_output_section->vma; 1700 1701 relocation += output_base + symbol->section->output_offset; 1702 1703 /* Add in supplied addend. */ 1704 relocation += reloc_entry->addend; 1705 1706 /* Here the variable relocation holds the final address of the 1707 symbol we are relocating against, plus any addend. */ 1708 if (output_bfd) 1709 { 1710 if (!howto->partial_inplace) 1711 { 1712 /* This is a partial relocation, and we want to apply the relocation 1713 to the reloc entry rather than the raw data. Everything except 1714 relocations against section symbols has already been handled 1715 above. */ 1716 1717 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM); 1718 reloc_entry->addend = relocation; 1719 reloc_entry->address += input_section->output_offset; 1720 return bfd_reloc_ok; 1721 } 1722 else 1723 { 1724 reloc_entry->address += input_section->output_offset; 1725 reloc_entry->addend = 0; 1726 } 1727 } 1728 1729 is_weak_undef = (bfd_is_und_section (symbol->section) 1730 && (symbol->flags & BSF_WEAK) != 0); 1731 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation, 1732 (bfd_byte *) data, (bfd_vma) octets, 1733 is_weak_undef, error_message); 1734 1735 if (flag == bfd_reloc_dangerous) 1736 { 1737 /* Add the symbol name to the error message. */ 1738 if (! *error_message) 1739 *error_message = ""; 1740 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)", 1741 strlen (symbol->name) + 17, 1742 symbol->name, reloc_entry->addend); 1743 } 1744 1745 return flag; 1746 } 1747 1748 1749 /* Set up an entry in the procedure linkage table. */ 1750 1751 static bfd_vma 1752 elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index) 1753 bfd *dynobj; 1754 bfd *output_bfd; 1755 unsigned reloc_index; 1756 { 1757 asection *splt, *sgotplt; 1758 bfd_vma plt_base, got_base; 1759 bfd_vma code_offset, lit_offset; 1760 int chunk; 1761 1762 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK; 1763 splt = elf_xtensa_get_plt_section (dynobj, chunk); 1764 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk); 1765 BFD_ASSERT (splt != NULL && sgotplt != NULL); 1766 1767 plt_base = splt->output_section->vma + splt->output_offset; 1768 got_base = sgotplt->output_section->vma + sgotplt->output_offset; 1769 1770 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4; 1771 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE; 1772 1773 /* Fill in the literal entry. This is the offset of the dynamic 1774 relocation entry. */ 1775 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela), 1776 sgotplt->contents + lit_offset); 1777 1778 /* Fill in the entry in the procedure linkage table. */ 1779 memcpy (splt->contents + code_offset, 1780 (bfd_big_endian (output_bfd) 1781 ? elf_xtensa_be_plt_entry 1782 : elf_xtensa_le_plt_entry), 1783 PLT_ENTRY_SIZE); 1784 bfd_put_16 (output_bfd, l32r_offset (got_base + 0, 1785 plt_base + code_offset + 3), 1786 splt->contents + code_offset + 4); 1787 bfd_put_16 (output_bfd, l32r_offset (got_base + 4, 1788 plt_base + code_offset + 6), 1789 splt->contents + code_offset + 7); 1790 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset, 1791 plt_base + code_offset + 9), 1792 splt->contents + code_offset + 10); 1793 1794 return plt_base + code_offset; 1795 } 1796 1797 1798 /* Relocate an Xtensa ELF section. This is invoked by the linker for 1799 both relocatable and final links. */ 1800 1801 static bfd_boolean 1802 elf_xtensa_relocate_section (output_bfd, info, input_bfd, 1803 input_section, contents, relocs, 1804 local_syms, local_sections) 1805 bfd *output_bfd; 1806 struct bfd_link_info *info; 1807 bfd *input_bfd; 1808 asection *input_section; 1809 bfd_byte *contents; 1810 Elf_Internal_Rela *relocs; 1811 Elf_Internal_Sym *local_syms; 1812 asection **local_sections; 1813 { 1814 Elf_Internal_Shdr *symtab_hdr; 1815 Elf_Internal_Rela *rel; 1816 Elf_Internal_Rela *relend; 1817 struct elf_link_hash_entry **sym_hashes; 1818 asection *srelgot, *srelplt; 1819 bfd *dynobj; 1820 property_table_entry *lit_table = 0; 1821 int ltblsize = 0; 1822 char *error_message = NULL; 1823 1824 if (xtensa_default_isa == NULL) 1825 xtensa_isa_init (); 1826 1827 dynobj = elf_hash_table (info)->dynobj; 1828 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1829 sym_hashes = elf_sym_hashes (input_bfd); 1830 1831 srelgot = NULL; 1832 srelplt = NULL; 1833 if (dynobj != NULL) 1834 { 1835 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");; 1836 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 1837 } 1838 1839 if (elf_hash_table (info)->dynamic_sections_created) 1840 { 1841 ltblsize = xtensa_read_table_entries (input_bfd, input_section, 1842 &lit_table, XTENSA_LIT_SEC_NAME); 1843 if (ltblsize < 0) 1844 return FALSE; 1845 } 1846 1847 rel = relocs; 1848 relend = relocs + input_section->reloc_count; 1849 for (; rel < relend; rel++) 1850 { 1851 int r_type; 1852 reloc_howto_type *howto; 1853 unsigned long r_symndx; 1854 struct elf_link_hash_entry *h; 1855 Elf_Internal_Sym *sym; 1856 asection *sec; 1857 bfd_vma relocation; 1858 bfd_reloc_status_type r; 1859 bfd_boolean is_weak_undef; 1860 bfd_boolean unresolved_reloc; 1861 bfd_boolean warned; 1862 1863 r_type = ELF32_R_TYPE (rel->r_info); 1864 if (r_type == (int) R_XTENSA_GNU_VTINHERIT 1865 || r_type == (int) R_XTENSA_GNU_VTENTRY) 1866 continue; 1867 1868 if (r_type < 0 || r_type >= (int) R_XTENSA_max) 1869 { 1870 bfd_set_error (bfd_error_bad_value); 1871 return FALSE; 1872 } 1873 howto = &elf_howto_table[r_type]; 1874 1875 r_symndx = ELF32_R_SYM (rel->r_info); 1876 1877 if (info->relocatable) 1878 { 1879 /* This is a relocatable link. 1880 1) If the reloc is against a section symbol, adjust 1881 according to the output section. 1882 2) If there is a new target for this relocation, 1883 the new target will be in the same output section. 1884 We adjust the relocation by the output section 1885 difference. */ 1886 1887 if (relaxing_section) 1888 { 1889 /* Check if this references a section in another input file. */ 1890 do_fix_for_relocatable_link (rel, input_bfd, input_section); 1891 r_type = ELF32_R_TYPE (rel->r_info); 1892 } 1893 1894 if (r_type == R_XTENSA_ASM_SIMPLIFY) 1895 { 1896 /* Convert ASM_SIMPLIFY into the simpler relocation 1897 so that they never escape a relaxing link. */ 1898 contract_asm_expansion (contents, input_section->_raw_size, rel); 1899 r_type = ELF32_R_TYPE (rel->r_info); 1900 } 1901 1902 /* This is a relocatable link, so we don't have to change 1903 anything unless the reloc is against a section symbol, 1904 in which case we have to adjust according to where the 1905 section symbol winds up in the output section. */ 1906 if (r_symndx < symtab_hdr->sh_info) 1907 { 1908 sym = local_syms + r_symndx; 1909 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1910 { 1911 sec = local_sections[r_symndx]; 1912 rel->r_addend += sec->output_offset + sym->st_value; 1913 } 1914 } 1915 1916 /* If there is an addend with a partial_inplace howto, 1917 then move the addend to the contents. This is a hack 1918 to work around problems with DWARF in relocatable links 1919 with some previous version of BFD. Now we can't easily get 1920 rid of the hack without breaking backward compatibility.... */ 1921 if (rel->r_addend) 1922 { 1923 howto = &elf_howto_table[r_type]; 1924 if (howto->partial_inplace) 1925 { 1926 r = elf_xtensa_do_reloc (howto, input_bfd, input_section, 1927 rel->r_addend, contents, 1928 rel->r_offset, FALSE, 1929 &error_message); 1930 if (r != bfd_reloc_ok) 1931 { 1932 if (!((*info->callbacks->reloc_dangerous) 1933 (info, error_message, input_bfd, input_section, 1934 rel->r_offset))) 1935 return FALSE; 1936 } 1937 rel->r_addend = 0; 1938 } 1939 } 1940 1941 /* Done with work for relocatable link; continue with next reloc. */ 1942 continue; 1943 } 1944 1945 /* This is a final link. */ 1946 1947 h = NULL; 1948 sym = NULL; 1949 sec = NULL; 1950 is_weak_undef = FALSE; 1951 unresolved_reloc = FALSE; 1952 warned = FALSE; 1953 1954 if (howto->partial_inplace) 1955 { 1956 /* Because R_XTENSA_32 was made partial_inplace to fix some 1957 problems with DWARF info in partial links, there may be 1958 an addend stored in the contents. Take it out of there 1959 and move it back into the addend field of the reloc. */ 1960 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset); 1961 bfd_put_32 (input_bfd, 0, contents + rel->r_offset); 1962 } 1963 1964 if (r_symndx < symtab_hdr->sh_info) 1965 { 1966 sym = local_syms + r_symndx; 1967 sec = local_sections[r_symndx]; 1968 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1969 } 1970 else 1971 { 1972 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1973 r_symndx, symtab_hdr, sym_hashes, 1974 h, sec, relocation, 1975 unresolved_reloc, warned); 1976 1977 if (relocation == 0 1978 && !unresolved_reloc 1979 && h->root.type == bfd_link_hash_undefweak) 1980 is_weak_undef = TRUE; 1981 } 1982 1983 if (relaxing_section) 1984 { 1985 /* Check if this references a section in another input file. */ 1986 do_fix_for_final_link (rel, input_section, &relocation); 1987 1988 /* Update some already cached values. */ 1989 r_type = ELF32_R_TYPE (rel->r_info); 1990 howto = &elf_howto_table[r_type]; 1991 } 1992 1993 /* Sanity check the address. */ 1994 if (rel->r_offset >= input_section->_raw_size 1995 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE) 1996 { 1997 bfd_set_error (bfd_error_bad_value); 1998 return FALSE; 1999 } 2000 2001 /* Generate dynamic relocations. */ 2002 if (elf_hash_table (info)->dynamic_sections_created) 2003 { 2004 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info); 2005 2006 if (dynamic_symbol && (r_type == R_XTENSA_OP0 2007 || r_type == R_XTENSA_OP1 2008 || r_type == R_XTENSA_OP2)) 2009 { 2010 /* This is an error. The symbol's real value won't be known 2011 until runtime and it's likely to be out of range anyway. */ 2012 const char *name = h->root.root.string; 2013 error_message = vsprint_msg ("invalid relocation for dynamic " 2014 "symbol", ": %s", 2015 strlen (name) + 2, name); 2016 if (!((*info->callbacks->reloc_dangerous) 2017 (info, error_message, input_bfd, input_section, 2018 rel->r_offset))) 2019 return FALSE; 2020 } 2021 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT) 2022 && (input_section->flags & SEC_ALLOC) != 0 2023 && (dynamic_symbol || info->shared)) 2024 { 2025 Elf_Internal_Rela outrel; 2026 bfd_byte *loc; 2027 asection *srel; 2028 2029 if (dynamic_symbol && r_type == R_XTENSA_PLT) 2030 srel = srelplt; 2031 else 2032 srel = srelgot; 2033 2034 BFD_ASSERT (srel != NULL); 2035 2036 outrel.r_offset = 2037 _bfd_elf_section_offset (output_bfd, info, 2038 input_section, rel->r_offset); 2039 2040 if ((outrel.r_offset | 1) == (bfd_vma) -1) 2041 memset (&outrel, 0, sizeof outrel); 2042 else 2043 { 2044 outrel.r_offset += (input_section->output_section->vma 2045 + input_section->output_offset); 2046 2047 /* Complain if the relocation is in a read-only section 2048 and not in a literal pool. */ 2049 if ((input_section->flags & SEC_READONLY) != 0 2050 && !elf_xtensa_in_literal_pool (lit_table, ltblsize, 2051 outrel.r_offset)) 2052 { 2053 error_message = 2054 _("dynamic relocation in read-only section"); 2055 if (!((*info->callbacks->reloc_dangerous) 2056 (info, error_message, input_bfd, input_section, 2057 rel->r_offset))) 2058 return FALSE; 2059 } 2060 2061 if (dynamic_symbol) 2062 { 2063 outrel.r_addend = rel->r_addend; 2064 rel->r_addend = 0; 2065 2066 if (r_type == R_XTENSA_32) 2067 { 2068 outrel.r_info = 2069 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT); 2070 relocation = 0; 2071 } 2072 else /* r_type == R_XTENSA_PLT */ 2073 { 2074 outrel.r_info = 2075 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT); 2076 2077 /* Create the PLT entry and set the initial 2078 contents of the literal entry to the address of 2079 the PLT entry. */ 2080 relocation = 2081 elf_xtensa_create_plt_entry (dynobj, output_bfd, 2082 srel->reloc_count); 2083 } 2084 unresolved_reloc = FALSE; 2085 } 2086 else 2087 { 2088 /* Generate a RELATIVE relocation. */ 2089 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE); 2090 outrel.r_addend = 0; 2091 } 2092 } 2093 2094 loc = (srel->contents 2095 + srel->reloc_count++ * sizeof (Elf32_External_Rela)); 2096 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 2097 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count 2098 <= srel->_cooked_size); 2099 } 2100 } 2101 2102 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2103 because such sections are not SEC_ALLOC and thus ld.so will 2104 not process them. */ 2105 if (unresolved_reloc 2106 && !((input_section->flags & SEC_DEBUGGING) != 0 2107 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 2108 (*_bfd_error_handler) 2109 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 2110 bfd_archive_filename (input_bfd), 2111 bfd_get_section_name (input_bfd, input_section), 2112 (long) rel->r_offset, 2113 h->root.root.string); 2114 2115 /* There's no point in calling bfd_perform_relocation here. 2116 Just go directly to our "special function". */ 2117 r = elf_xtensa_do_reloc (howto, input_bfd, input_section, 2118 relocation + rel->r_addend, 2119 contents, rel->r_offset, is_weak_undef, 2120 &error_message); 2121 2122 if (r != bfd_reloc_ok && !warned) 2123 { 2124 const char *name; 2125 2126 BFD_ASSERT (r == bfd_reloc_dangerous); 2127 BFD_ASSERT (error_message != (char *) NULL); 2128 2129 if (h != NULL) 2130 name = h->root.root.string; 2131 else 2132 { 2133 name = bfd_elf_string_from_elf_section 2134 (input_bfd, symtab_hdr->sh_link, sym->st_name); 2135 if (name && *name == '\0') 2136 name = bfd_section_name (input_bfd, sec); 2137 } 2138 if (name) 2139 error_message = vsprint_msg (error_message, ": %s", 2140 strlen (name), name); 2141 if (!((*info->callbacks->reloc_dangerous) 2142 (info, error_message, input_bfd, input_section, 2143 rel->r_offset))) 2144 return FALSE; 2145 } 2146 } 2147 2148 if (lit_table) 2149 free (lit_table); 2150 2151 input_section->reloc_done = TRUE; 2152 2153 return TRUE; 2154 } 2155 2156 2157 /* Finish up dynamic symbol handling. There's not much to do here since 2158 the PLT and GOT entries are all set up by relocate_section. */ 2159 2160 static bfd_boolean 2161 elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym) 2162 bfd *output_bfd ATTRIBUTE_UNUSED; 2163 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2164 struct elf_link_hash_entry *h; 2165 Elf_Internal_Sym *sym; 2166 { 2167 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 2168 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 2169 { 2170 /* Mark the symbol as undefined, rather than as defined in 2171 the .plt section. Leave the value alone. */ 2172 sym->st_shndx = SHN_UNDEF; 2173 } 2174 2175 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2176 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2177 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2178 sym->st_shndx = SHN_ABS; 2179 2180 return TRUE; 2181 } 2182 2183 2184 /* Combine adjacent literal table entries in the output. Adjacent 2185 entries within each input section may have been removed during 2186 relaxation, but we repeat the process here, even though it's too late 2187 to shrink the output section, because it's important to minimize the 2188 number of literal table entries to reduce the start-up work for the 2189 runtime linker. Returns the number of remaining table entries or -1 2190 on error. */ 2191 2192 static int 2193 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc) 2194 bfd *output_bfd; 2195 asection *sxtlit; 2196 asection *sgotloc; 2197 { 2198 bfd_byte *contents; 2199 property_table_entry *table; 2200 bfd_size_type section_size, sgotloc_size; 2201 bfd_vma offset; 2202 int n, m, num; 2203 2204 section_size = (sxtlit->_cooked_size != 0 2205 ? sxtlit->_cooked_size : sxtlit->_raw_size); 2206 BFD_ASSERT (section_size % 8 == 0); 2207 num = section_size / 8; 2208 2209 sgotloc_size = (sgotloc->_cooked_size != 0 2210 ? sgotloc->_cooked_size : sgotloc->_raw_size); 2211 if (sgotloc_size != section_size) 2212 { 2213 (*_bfd_error_handler) 2214 ("internal inconsistency in size of .got.loc section"); 2215 return -1; 2216 } 2217 2218 contents = (bfd_byte *) bfd_malloc (section_size); 2219 table = (property_table_entry *) 2220 bfd_malloc (num * sizeof (property_table_entry)); 2221 if (contents == 0 || table == 0) 2222 return -1; 2223 2224 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this 2225 propagates to the output section, where it doesn't really apply and 2226 where it breaks the following call to bfd_get_section_contents. */ 2227 sxtlit->flags &= ~SEC_IN_MEMORY; 2228 2229 if (! bfd_get_section_contents (output_bfd, sxtlit, contents, 0, 2230 section_size)) 2231 return -1; 2232 2233 /* There should never be any relocations left at this point, so this 2234 is quite a bit easier than what is done during relaxation. */ 2235 2236 /* Copy the raw contents into a property table array and sort it. */ 2237 offset = 0; 2238 for (n = 0; n < num; n++) 2239 { 2240 table[n].address = bfd_get_32 (output_bfd, &contents[offset]); 2241 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]); 2242 offset += 8; 2243 } 2244 qsort (table, num, sizeof (property_table_entry), property_table_compare); 2245 2246 for (n = 0; n < num; n++) 2247 { 2248 bfd_boolean remove = FALSE; 2249 2250 if (table[n].size == 0) 2251 remove = TRUE; 2252 else if (n > 0 && 2253 (table[n-1].address + table[n-1].size == table[n].address)) 2254 { 2255 table[n-1].size += table[n].size; 2256 remove = TRUE; 2257 } 2258 2259 if (remove) 2260 { 2261 for (m = n; m < num - 1; m++) 2262 { 2263 table[m].address = table[m+1].address; 2264 table[m].size = table[m+1].size; 2265 } 2266 2267 n--; 2268 num--; 2269 } 2270 } 2271 2272 /* Copy the data back to the raw contents. */ 2273 offset = 0; 2274 for (n = 0; n < num; n++) 2275 { 2276 bfd_put_32 (output_bfd, table[n].address, &contents[offset]); 2277 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]); 2278 offset += 8; 2279 } 2280 2281 /* Clear the removed bytes. */ 2282 if ((bfd_size_type) (num * 8) < section_size) 2283 { 2284 memset (&contents[num * 8], 0, section_size - num * 8); 2285 sxtlit->_cooked_size = num * 8; 2286 } 2287 2288 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0, 2289 section_size)) 2290 return -1; 2291 2292 /* Copy the contents to ".got.loc". */ 2293 memcpy (sgotloc->contents, contents, section_size); 2294 2295 free (contents); 2296 free (table); 2297 return num; 2298 } 2299 2300 2301 /* Finish up the dynamic sections. */ 2302 2303 static bfd_boolean 2304 elf_xtensa_finish_dynamic_sections (output_bfd, info) 2305 bfd *output_bfd; 2306 struct bfd_link_info *info; 2307 { 2308 bfd *dynobj; 2309 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc; 2310 Elf32_External_Dyn *dyncon, *dynconend; 2311 int num_xtlit_entries; 2312 2313 if (! elf_hash_table (info)->dynamic_sections_created) 2314 return TRUE; 2315 2316 dynobj = elf_hash_table (info)->dynobj; 2317 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2318 BFD_ASSERT (sdyn != NULL); 2319 2320 /* Set the first entry in the global offset table to the address of 2321 the dynamic section. */ 2322 sgot = bfd_get_section_by_name (dynobj, ".got"); 2323 if (sgot) 2324 { 2325 BFD_ASSERT (sgot->_raw_size == 4); 2326 if (sdyn == NULL) 2327 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 2328 else 2329 bfd_put_32 (output_bfd, 2330 sdyn->output_section->vma + sdyn->output_offset, 2331 sgot->contents); 2332 } 2333 2334 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 2335 if (srelplt != NULL && srelplt->_raw_size != 0) 2336 { 2337 asection *sgotplt, *srelgot, *spltlittbl; 2338 int chunk, plt_chunks, plt_entries; 2339 Elf_Internal_Rela irela; 2340 bfd_byte *loc; 2341 unsigned rtld_reloc; 2342 2343 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");; 2344 BFD_ASSERT (srelgot != NULL); 2345 2346 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt"); 2347 BFD_ASSERT (spltlittbl != NULL); 2348 2349 /* Find the first XTENSA_RTLD relocation. Presumably the rest 2350 of them follow immediately after.... */ 2351 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++) 2352 { 2353 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela); 2354 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela); 2355 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD) 2356 break; 2357 } 2358 BFD_ASSERT (rtld_reloc < srelgot->reloc_count); 2359 2360 plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela)); 2361 plt_chunks = 2362 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK; 2363 2364 for (chunk = 0; chunk < plt_chunks; chunk++) 2365 { 2366 int chunk_entries = 0; 2367 2368 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk); 2369 BFD_ASSERT (sgotplt != NULL); 2370 2371 /* Emit special RTLD relocations for the first two entries in 2372 each chunk of the .got.plt section. */ 2373 2374 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela); 2375 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela); 2376 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD); 2377 irela.r_offset = (sgotplt->output_section->vma 2378 + sgotplt->output_offset); 2379 irela.r_addend = 1; /* tell rtld to set value to resolver function */ 2380 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc); 2381 rtld_reloc += 1; 2382 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count); 2383 2384 /* Next literal immediately follows the first. */ 2385 loc += sizeof (Elf32_External_Rela); 2386 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela); 2387 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD); 2388 irela.r_offset = (sgotplt->output_section->vma 2389 + sgotplt->output_offset + 4); 2390 /* Tell rtld to set value to object's link map. */ 2391 irela.r_addend = 2; 2392 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc); 2393 rtld_reloc += 1; 2394 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count); 2395 2396 /* Fill in the literal table. */ 2397 if (chunk < plt_chunks - 1) 2398 chunk_entries = PLT_ENTRIES_PER_CHUNK; 2399 else 2400 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK); 2401 2402 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size); 2403 bfd_put_32 (output_bfd, 2404 sgotplt->output_section->vma + sgotplt->output_offset, 2405 spltlittbl->contents + (chunk * 8) + 0); 2406 bfd_put_32 (output_bfd, 2407 8 + (chunk_entries * 4), 2408 spltlittbl->contents + (chunk * 8) + 4); 2409 } 2410 2411 /* All the dynamic relocations have been emitted at this point. 2412 Make sure the relocation sections are the correct size. */ 2413 if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela) 2414 * srelgot->reloc_count) 2415 || srelplt->_cooked_size != (sizeof (Elf32_External_Rela) 2416 * srelplt->reloc_count)) 2417 abort (); 2418 2419 /* The .xt.lit.plt section has just been modified. This must 2420 happen before the code below which combines adjacent literal 2421 table entries, and the .xt.lit.plt contents have to be forced to 2422 the output here. */ 2423 if (! bfd_set_section_contents (output_bfd, 2424 spltlittbl->output_section, 2425 spltlittbl->contents, 2426 spltlittbl->output_offset, 2427 spltlittbl->_raw_size)) 2428 return FALSE; 2429 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */ 2430 spltlittbl->flags &= ~SEC_HAS_CONTENTS; 2431 } 2432 2433 /* Combine adjacent literal table entries. */ 2434 BFD_ASSERT (! info->relocatable); 2435 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit"); 2436 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc"); 2437 BFD_ASSERT (sxtlit && sgotloc); 2438 num_xtlit_entries = 2439 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc); 2440 if (num_xtlit_entries < 0) 2441 return FALSE; 2442 2443 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2444 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 2445 for (; dyncon < dynconend; dyncon++) 2446 { 2447 Elf_Internal_Dyn dyn; 2448 const char *name; 2449 asection *s; 2450 2451 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2452 2453 switch (dyn.d_tag) 2454 { 2455 default: 2456 break; 2457 2458 case DT_XTENSA_GOT_LOC_SZ: 2459 dyn.d_un.d_val = num_xtlit_entries; 2460 break; 2461 2462 case DT_XTENSA_GOT_LOC_OFF: 2463 name = ".got.loc"; 2464 goto get_vma; 2465 case DT_PLTGOT: 2466 name = ".got"; 2467 goto get_vma; 2468 case DT_JMPREL: 2469 name = ".rela.plt"; 2470 get_vma: 2471 s = bfd_get_section_by_name (output_bfd, name); 2472 BFD_ASSERT (s); 2473 dyn.d_un.d_ptr = s->vma; 2474 break; 2475 2476 case DT_PLTRELSZ: 2477 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2478 BFD_ASSERT (s); 2479 dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size); 2480 break; 2481 2482 case DT_RELASZ: 2483 /* Adjust RELASZ to not include JMPREL. This matches what 2484 glibc expects and what is done for several other ELF 2485 targets (e.g., i386, alpha), but the "correct" behavior 2486 seems to be unresolved. Since the linker script arranges 2487 for .rela.plt to follow all other relocation sections, we 2488 don't have to worry about changing the DT_RELA entry. */ 2489 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2490 if (s) 2491 { 2492 dyn.d_un.d_val -= 2493 (s->_cooked_size ? s->_cooked_size : s->_raw_size); 2494 } 2495 break; 2496 } 2497 2498 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2499 } 2500 2501 return TRUE; 2502 } 2503 2504 2505 /* Functions for dealing with the e_flags field. */ 2506 2507 /* Merge backend specific data from an object file to the output 2508 object file when linking. */ 2509 2510 static bfd_boolean 2511 elf_xtensa_merge_private_bfd_data (ibfd, obfd) 2512 bfd *ibfd; 2513 bfd *obfd; 2514 { 2515 unsigned out_mach, in_mach; 2516 flagword out_flag, in_flag; 2517 2518 /* Check if we have the same endianess. */ 2519 if (!_bfd_generic_verify_endian_match (ibfd, obfd)) 2520 return FALSE; 2521 2522 /* Don't even pretend to support mixed-format linking. */ 2523 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2524 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2525 return FALSE; 2526 2527 out_flag = elf_elfheader (obfd)->e_flags; 2528 in_flag = elf_elfheader (ibfd)->e_flags; 2529 2530 out_mach = out_flag & EF_XTENSA_MACH; 2531 in_mach = in_flag & EF_XTENSA_MACH; 2532 if (out_mach != in_mach) 2533 { 2534 (*_bfd_error_handler) 2535 ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x", 2536 bfd_archive_filename (ibfd), out_mach, in_mach); 2537 bfd_set_error (bfd_error_wrong_format); 2538 return FALSE; 2539 } 2540 2541 if (! elf_flags_init (obfd)) 2542 { 2543 elf_flags_init (obfd) = TRUE; 2544 elf_elfheader (obfd)->e_flags = in_flag; 2545 2546 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 2547 && bfd_get_arch_info (obfd)->the_default) 2548 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 2549 bfd_get_mach (ibfd)); 2550 2551 return TRUE; 2552 } 2553 2554 if ((out_flag & EF_XTENSA_XT_INSN) != 2555 (in_flag & EF_XTENSA_XT_INSN)) 2556 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_INSN); 2557 2558 if ((out_flag & EF_XTENSA_XT_LIT) != 2559 (in_flag & EF_XTENSA_XT_LIT)) 2560 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_LIT); 2561 2562 return TRUE; 2563 } 2564 2565 2566 static bfd_boolean 2567 elf_xtensa_set_private_flags (abfd, flags) 2568 bfd *abfd; 2569 flagword flags; 2570 { 2571 BFD_ASSERT (!elf_flags_init (abfd) 2572 || elf_elfheader (abfd)->e_flags == flags); 2573 2574 elf_elfheader (abfd)->e_flags |= flags; 2575 elf_flags_init (abfd) = TRUE; 2576 2577 return TRUE; 2578 } 2579 2580 2581 extern flagword 2582 elf_xtensa_get_private_bfd_flags (abfd) 2583 bfd *abfd; 2584 { 2585 return elf_elfheader (abfd)->e_flags; 2586 } 2587 2588 2589 static bfd_boolean 2590 elf_xtensa_print_private_bfd_data (abfd, farg) 2591 bfd *abfd; 2592 PTR farg; 2593 { 2594 FILE *f = (FILE *) farg; 2595 flagword e_flags = elf_elfheader (abfd)->e_flags; 2596 2597 fprintf (f, "\nXtensa header:\n"); 2598 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH) 2599 fprintf (f, "\nMachine = Base\n"); 2600 else 2601 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH); 2602 2603 fprintf (f, "Insn tables = %s\n", 2604 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false"); 2605 2606 fprintf (f, "Literal tables = %s\n", 2607 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false"); 2608 2609 return _bfd_elf_print_private_bfd_data (abfd, farg); 2610 } 2611 2612 2613 /* Set the right machine number for an Xtensa ELF file. */ 2614 2615 static bfd_boolean 2616 elf_xtensa_object_p (abfd) 2617 bfd *abfd; 2618 { 2619 int mach; 2620 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH; 2621 2622 switch (arch) 2623 { 2624 case E_XTENSA_MACH: 2625 mach = bfd_mach_xtensa; 2626 break; 2627 default: 2628 return FALSE; 2629 } 2630 2631 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach); 2632 return TRUE; 2633 } 2634 2635 2636 /* The final processing done just before writing out an Xtensa ELF object 2637 file. This gets the Xtensa architecture right based on the machine 2638 number. */ 2639 2640 static void 2641 elf_xtensa_final_write_processing (abfd, linker) 2642 bfd *abfd; 2643 bfd_boolean linker ATTRIBUTE_UNUSED; 2644 { 2645 int mach; 2646 unsigned long val; 2647 2648 switch (mach = bfd_get_mach (abfd)) 2649 { 2650 case bfd_mach_xtensa: 2651 val = E_XTENSA_MACH; 2652 break; 2653 default: 2654 return; 2655 } 2656 2657 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH); 2658 elf_elfheader (abfd)->e_flags |= val; 2659 } 2660 2661 2662 static enum elf_reloc_type_class 2663 elf_xtensa_reloc_type_class (rela) 2664 const Elf_Internal_Rela *rela; 2665 { 2666 switch ((int) ELF32_R_TYPE (rela->r_info)) 2667 { 2668 case R_XTENSA_RELATIVE: 2669 return reloc_class_relative; 2670 case R_XTENSA_JMP_SLOT: 2671 return reloc_class_plt; 2672 default: 2673 return reloc_class_normal; 2674 } 2675 } 2676 2677 2678 static bfd_boolean 2679 elf_xtensa_discard_info_for_section (abfd, cookie, info, sec) 2680 bfd *abfd; 2681 struct elf_reloc_cookie *cookie; 2682 struct bfd_link_info *info; 2683 asection *sec; 2684 { 2685 bfd_byte *contents; 2686 bfd_vma section_size; 2687 bfd_vma offset, actual_offset; 2688 size_t removed_bytes = 0; 2689 2690 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size); 2691 if (section_size == 0 || section_size % 8 != 0) 2692 return FALSE; 2693 2694 if (sec->output_section 2695 && bfd_is_abs_section (sec->output_section)) 2696 return FALSE; 2697 2698 contents = retrieve_contents (abfd, sec, info->keep_memory); 2699 if (!contents) 2700 return FALSE; 2701 2702 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory); 2703 if (!cookie->rels) 2704 { 2705 release_contents (sec, contents); 2706 return FALSE; 2707 } 2708 2709 cookie->rel = cookie->rels; 2710 cookie->relend = cookie->rels + sec->reloc_count; 2711 2712 for (offset = 0; offset < section_size; offset += 8) 2713 { 2714 actual_offset = offset - removed_bytes; 2715 2716 /* The ...symbol_deleted_p function will skip over relocs but it 2717 won't adjust their offsets, so do that here. */ 2718 while (cookie->rel < cookie->relend 2719 && cookie->rel->r_offset < offset) 2720 { 2721 cookie->rel->r_offset -= removed_bytes; 2722 cookie->rel++; 2723 } 2724 2725 while (cookie->rel < cookie->relend 2726 && cookie->rel->r_offset == offset) 2727 { 2728 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie)) 2729 { 2730 /* Remove the table entry. (If the reloc type is NONE, then 2731 the entry has already been merged with another and deleted 2732 during relaxation.) */ 2733 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE) 2734 { 2735 /* Shift the contents up. */ 2736 if (offset + 8 < section_size) 2737 memmove (&contents[actual_offset], 2738 &contents[actual_offset+8], 2739 section_size - offset - 8); 2740 removed_bytes += 8; 2741 } 2742 2743 /* Remove this relocation. */ 2744 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 2745 } 2746 2747 /* Adjust the relocation offset for previous removals. This 2748 should not be done before calling ...symbol_deleted_p 2749 because it might mess up the offset comparisons there. 2750 Make sure the offset doesn't underflow in the case where 2751 the first entry is removed. */ 2752 if (cookie->rel->r_offset >= removed_bytes) 2753 cookie->rel->r_offset -= removed_bytes; 2754 else 2755 cookie->rel->r_offset = 0; 2756 2757 cookie->rel++; 2758 } 2759 } 2760 2761 if (removed_bytes != 0) 2762 { 2763 /* Adjust any remaining relocs (shouldn't be any). */ 2764 for (; cookie->rel < cookie->relend; cookie->rel++) 2765 { 2766 if (cookie->rel->r_offset >= removed_bytes) 2767 cookie->rel->r_offset -= removed_bytes; 2768 else 2769 cookie->rel->r_offset = 0; 2770 } 2771 2772 /* Clear the removed bytes. */ 2773 memset (&contents[section_size - removed_bytes], 0, removed_bytes); 2774 2775 pin_contents (sec, contents); 2776 pin_internal_relocs (sec, cookie->rels); 2777 2778 sec->_cooked_size = section_size - removed_bytes; 2779 /* Also shrink _raw_size. See comments in relax_property_section. */ 2780 sec->_raw_size = sec->_cooked_size; 2781 2782 if (xtensa_is_littable_section (sec)) 2783 { 2784 bfd *dynobj = elf_hash_table (info)->dynobj; 2785 if (dynobj) 2786 { 2787 asection *sgotloc = 2788 bfd_get_section_by_name (dynobj, ".got.loc"); 2789 if (sgotloc) 2790 { 2791 bfd_size_type sgotloc_size = 2792 (sgotloc->_cooked_size ? sgotloc->_cooked_size 2793 : sgotloc->_raw_size); 2794 sgotloc->_cooked_size = sgotloc_size - removed_bytes; 2795 sgotloc->_raw_size = sgotloc_size - removed_bytes; 2796 } 2797 } 2798 } 2799 } 2800 else 2801 { 2802 release_contents (sec, contents); 2803 release_internal_relocs (sec, cookie->rels); 2804 } 2805 2806 return (removed_bytes != 0); 2807 } 2808 2809 2810 static bfd_boolean 2811 elf_xtensa_discard_info (abfd, cookie, info) 2812 bfd *abfd; 2813 struct elf_reloc_cookie *cookie; 2814 struct bfd_link_info *info; 2815 { 2816 asection *sec; 2817 bfd_boolean changed = FALSE; 2818 2819 for (sec = abfd->sections; sec != NULL; sec = sec->next) 2820 { 2821 if (xtensa_is_property_section (sec)) 2822 { 2823 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)) 2824 changed = TRUE; 2825 } 2826 } 2827 2828 return changed; 2829 } 2830 2831 2832 static bfd_boolean 2833 elf_xtensa_ignore_discarded_relocs (sec) 2834 asection *sec; 2835 { 2836 return xtensa_is_property_section (sec); 2837 } 2838 2839 2840 /* Support for core dump NOTE sections. */ 2841 2842 static bfd_boolean 2843 elf_xtensa_grok_prstatus (abfd, note) 2844 bfd *abfd; 2845 Elf_Internal_Note *note; 2846 { 2847 int offset; 2848 unsigned int raw_size; 2849 2850 /* The size for Xtensa is variable, so don't try to recognize the format 2851 based on the size. Just assume this is GNU/Linux. */ 2852 2853 /* pr_cursig */ 2854 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 2855 2856 /* pr_pid */ 2857 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); 2858 2859 /* pr_reg */ 2860 offset = 72; 2861 raw_size = note->descsz - offset - 4; 2862 2863 /* Make a ".reg/999" section. */ 2864 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2865 raw_size, note->descpos + offset); 2866 } 2867 2868 2869 static bfd_boolean 2870 elf_xtensa_grok_psinfo (abfd, note) 2871 bfd *abfd; 2872 Elf_Internal_Note *note; 2873 { 2874 switch (note->descsz) 2875 { 2876 default: 2877 return FALSE; 2878 2879 case 128: /* GNU/Linux elf_prpsinfo */ 2880 elf_tdata (abfd)->core_program 2881 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); 2882 elf_tdata (abfd)->core_command 2883 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); 2884 } 2885 2886 /* Note that for some reason, a spurious space is tacked 2887 onto the end of the args in some (at least one anyway) 2888 implementations, so strip it off if it exists. */ 2889 2890 { 2891 char *command = elf_tdata (abfd)->core_command; 2892 int n = strlen (command); 2893 2894 if (0 < n && command[n - 1] == ' ') 2895 command[n - 1] = '\0'; 2896 } 2897 2898 return TRUE; 2899 } 2900 2901 2902 /* Generic Xtensa configurability stuff. */ 2903 2904 static xtensa_opcode callx0_op = XTENSA_UNDEFINED; 2905 static xtensa_opcode callx4_op = XTENSA_UNDEFINED; 2906 static xtensa_opcode callx8_op = XTENSA_UNDEFINED; 2907 static xtensa_opcode callx12_op = XTENSA_UNDEFINED; 2908 static xtensa_opcode call0_op = XTENSA_UNDEFINED; 2909 static xtensa_opcode call4_op = XTENSA_UNDEFINED; 2910 static xtensa_opcode call8_op = XTENSA_UNDEFINED; 2911 static xtensa_opcode call12_op = XTENSA_UNDEFINED; 2912 2913 static void 2914 init_call_opcodes () 2915 { 2916 if (callx0_op == XTENSA_UNDEFINED) 2917 { 2918 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0"); 2919 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4"); 2920 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8"); 2921 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12"); 2922 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0"); 2923 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4"); 2924 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8"); 2925 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12"); 2926 } 2927 } 2928 2929 2930 static bfd_boolean 2931 is_indirect_call_opcode (opcode) 2932 xtensa_opcode opcode; 2933 { 2934 init_call_opcodes (); 2935 return (opcode == callx0_op 2936 || opcode == callx4_op 2937 || opcode == callx8_op 2938 || opcode == callx12_op); 2939 } 2940 2941 2942 static bfd_boolean 2943 is_direct_call_opcode (opcode) 2944 xtensa_opcode opcode; 2945 { 2946 init_call_opcodes (); 2947 return (opcode == call0_op 2948 || opcode == call4_op 2949 || opcode == call8_op 2950 || opcode == call12_op); 2951 } 2952 2953 2954 static bfd_boolean 2955 is_windowed_call_opcode (opcode) 2956 xtensa_opcode opcode; 2957 { 2958 init_call_opcodes (); 2959 return (opcode == call4_op 2960 || opcode == call8_op 2961 || opcode == call12_op 2962 || opcode == callx4_op 2963 || opcode == callx8_op 2964 || opcode == callx12_op); 2965 } 2966 2967 2968 static xtensa_opcode 2969 get_l32r_opcode (void) 2970 { 2971 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED; 2972 if (l32r_opcode == XTENSA_UNDEFINED) 2973 { 2974 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r"); 2975 BFD_ASSERT (l32r_opcode != XTENSA_UNDEFINED); 2976 } 2977 return l32r_opcode; 2978 } 2979 2980 2981 static bfd_vma 2982 l32r_offset (addr, pc) 2983 bfd_vma addr; 2984 bfd_vma pc; 2985 { 2986 bfd_vma offset; 2987 2988 offset = addr - ((pc+3) & -4); 2989 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0); 2990 offset = (signed int) offset >> 2; 2991 BFD_ASSERT ((signed int) offset >> 16 == -1); 2992 return offset; 2993 } 2994 2995 2996 /* Get the operand number for a PC-relative relocation. 2997 If the relocation is not a PC-relative one, return (-1). */ 2998 2999 static int 3000 get_relocation_opnd (irel) 3001 Elf_Internal_Rela *irel; 3002 { 3003 if (ELF32_R_TYPE (irel->r_info) < R_XTENSA_OP0 3004 || ELF32_R_TYPE (irel->r_info) >= R_XTENSA_max) 3005 return -1; 3006 return ELF32_R_TYPE (irel->r_info) - R_XTENSA_OP0; 3007 } 3008 3009 3010 /* Get the opcode for a relocation. */ 3011 3012 static xtensa_opcode 3013 get_relocation_opcode (sec, contents, irel) 3014 asection *sec; 3015 bfd_byte *contents; 3016 Elf_Internal_Rela *irel; 3017 { 3018 static xtensa_insnbuf ibuff = NULL; 3019 xtensa_isa isa = xtensa_default_isa; 3020 3021 if (get_relocation_opnd (irel) == -1) 3022 return XTENSA_UNDEFINED; 3023 3024 if (contents == NULL) 3025 return XTENSA_UNDEFINED; 3026 3027 if (sec->_raw_size <= irel->r_offset) 3028 return XTENSA_UNDEFINED; 3029 3030 if (ibuff == NULL) 3031 ibuff = xtensa_insnbuf_alloc (isa); 3032 3033 /* Decode the instruction. */ 3034 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset]); 3035 return xtensa_decode_insn (isa, ibuff); 3036 } 3037 3038 3039 bfd_boolean 3040 is_l32r_relocation (sec, contents, irel) 3041 asection *sec; 3042 bfd_byte *contents; 3043 Elf_Internal_Rela *irel; 3044 { 3045 xtensa_opcode opcode; 3046 3047 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_OP1) 3048 return FALSE; 3049 3050 opcode = get_relocation_opcode (sec, contents, irel); 3051 return (opcode == get_l32r_opcode ()); 3052 } 3053 3054 3055 /* Code for transforming CALLs at link-time. */ 3056 3057 static bfd_reloc_status_type 3058 elf_xtensa_do_asm_simplify (contents, address, content_length) 3059 bfd_byte *contents; 3060 bfd_vma address; 3061 bfd_vma content_length; 3062 { 3063 static xtensa_insnbuf insnbuf = NULL; 3064 xtensa_opcode opcode; 3065 xtensa_operand operand; 3066 xtensa_opcode direct_call_opcode; 3067 xtensa_isa isa = xtensa_default_isa; 3068 bfd_byte *chbuf = contents + address; 3069 int opn; 3070 3071 if (insnbuf == NULL) 3072 insnbuf = xtensa_insnbuf_alloc (isa); 3073 3074 if (content_length < address) 3075 { 3076 (*_bfd_error_handler) 3077 ("Attempt to convert L32R/CALLX to CALL failed"); 3078 return bfd_reloc_other; 3079 } 3080 3081 opcode = get_expanded_call_opcode (chbuf, content_length - address); 3082 direct_call_opcode = swap_callx_for_call_opcode (opcode); 3083 if (direct_call_opcode == XTENSA_UNDEFINED) 3084 { 3085 (*_bfd_error_handler) 3086 ("Attempt to convert L32R/CALLX to CALL failed"); 3087 return bfd_reloc_other; 3088 } 3089 3090 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */ 3091 opcode = xtensa_opcode_lookup (isa, "or"); 3092 xtensa_encode_insn (isa, opcode, insnbuf); 3093 for (opn = 0; opn < 3; opn++) 3094 { 3095 operand = xtensa_get_operand (isa, opcode, opn); 3096 xtensa_operand_set_field (operand, insnbuf, 1); 3097 } 3098 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf); 3099 3100 /* Assemble a CALL ("callN 0") into the 3 byte offset. */ 3101 xtensa_encode_insn (isa, direct_call_opcode, insnbuf); 3102 operand = xtensa_get_operand (isa, opcode, 0); 3103 xtensa_operand_set_field (operand, insnbuf, 0); 3104 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3); 3105 3106 return bfd_reloc_ok; 3107 } 3108 3109 3110 static bfd_reloc_status_type 3111 contract_asm_expansion (contents, content_length, irel) 3112 bfd_byte *contents; 3113 bfd_vma content_length; 3114 Elf_Internal_Rela *irel; 3115 { 3116 bfd_reloc_status_type retval = 3117 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length); 3118 3119 if (retval != bfd_reloc_ok) 3120 return retval; 3121 3122 /* Update the irel->r_offset field so that the right immediate and 3123 the right instruction are modified during the relocation. */ 3124 irel->r_offset += 3; 3125 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_OP0); 3126 return bfd_reloc_ok; 3127 } 3128 3129 3130 static xtensa_opcode 3131 swap_callx_for_call_opcode (opcode) 3132 xtensa_opcode opcode; 3133 { 3134 init_call_opcodes (); 3135 3136 if (opcode == callx0_op) return call0_op; 3137 if (opcode == callx4_op) return call4_op; 3138 if (opcode == callx8_op) return call8_op; 3139 if (opcode == callx12_op) return call12_op; 3140 3141 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */ 3142 return XTENSA_UNDEFINED; 3143 } 3144 3145 3146 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and 3147 if so, return the CALLX opcode. If not, return XTENSA_UNDEFINED. */ 3148 3149 #define L32R_TARGET_REG_OPERAND 0 3150 #define CALLN_SOURCE_OPERAND 0 3151 3152 static xtensa_opcode 3153 get_expanded_call_opcode (buf, bufsize) 3154 bfd_byte *buf; 3155 int bufsize; 3156 { 3157 static xtensa_insnbuf insnbuf = NULL; 3158 xtensa_opcode opcode; 3159 xtensa_operand operand; 3160 xtensa_isa isa = xtensa_default_isa; 3161 uint32 regno, call_regno; 3162 3163 /* Buffer must be at least 6 bytes. */ 3164 if (bufsize < 6) 3165 return XTENSA_UNDEFINED; 3166 3167 if (insnbuf == NULL) 3168 insnbuf = xtensa_insnbuf_alloc (isa); 3169 3170 xtensa_insnbuf_from_chars (isa, insnbuf, buf); 3171 opcode = xtensa_decode_insn (isa, insnbuf); 3172 3173 if (opcode != get_l32r_opcode ()) 3174 return XTENSA_UNDEFINED; 3175 3176 operand = xtensa_get_operand (isa, opcode, L32R_TARGET_REG_OPERAND); 3177 regno = xtensa_operand_decode 3178 (operand, xtensa_operand_get_field (operand, insnbuf)); 3179 3180 /* Next instruction should be an CALLXn with operand 0 == regno. */ 3181 xtensa_insnbuf_from_chars (isa, insnbuf, 3182 buf + xtensa_insn_length (isa, opcode)); 3183 opcode = xtensa_decode_insn (isa, insnbuf); 3184 3185 if (!is_indirect_call_opcode (opcode)) 3186 return XTENSA_UNDEFINED; 3187 3188 operand = xtensa_get_operand (isa, opcode, CALLN_SOURCE_OPERAND); 3189 call_regno = xtensa_operand_decode 3190 (operand, xtensa_operand_get_field (operand, insnbuf)); 3191 if (call_regno != regno) 3192 return XTENSA_UNDEFINED; 3193 3194 return opcode; 3195 } 3196 3197 3198 /* Data structures used during relaxation. */ 3199 3200 /* r_reloc: relocation values. */ 3201 3202 /* Through the relaxation process, we need to keep track of the values 3203 that will result from evaluating relocations. The standard ELF 3204 relocation structure is not sufficient for this purpose because we're 3205 operating on multiple input files at once, so we need to know which 3206 input file a relocation refers to. The r_reloc structure thus 3207 records both the input file (bfd) and ELF relocation. 3208 3209 For efficiency, an r_reloc also contains a "target_offset" field to 3210 cache the target-section-relative offset value that is represented by 3211 the relocation. */ 3212 3213 typedef struct r_reloc_struct r_reloc; 3214 3215 struct r_reloc_struct 3216 { 3217 bfd *abfd; 3218 Elf_Internal_Rela rela; 3219 bfd_vma target_offset; 3220 }; 3221 3222 static bfd_boolean r_reloc_is_const 3223 PARAMS ((const r_reloc *)); 3224 static void r_reloc_init 3225 PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *)); 3226 static bfd_vma r_reloc_get_target_offset 3227 PARAMS ((const r_reloc *)); 3228 static asection *r_reloc_get_section 3229 PARAMS ((const r_reloc *)); 3230 static bfd_boolean r_reloc_is_defined 3231 PARAMS ((const r_reloc *)); 3232 static struct elf_link_hash_entry *r_reloc_get_hash_entry 3233 PARAMS ((const r_reloc *)); 3234 3235 3236 /* The r_reloc structure is included by value in literal_value, but not 3237 every literal_value has an associated relocation -- some are simple 3238 constants. In such cases, we set all the fields in the r_reloc 3239 struct to zero. The r_reloc_is_const function should be used to 3240 detect this case. */ 3241 3242 static bfd_boolean 3243 r_reloc_is_const (r_rel) 3244 const r_reloc *r_rel; 3245 { 3246 return (r_rel->abfd == NULL); 3247 } 3248 3249 3250 static void 3251 r_reloc_init (r_rel, abfd, irel) 3252 r_reloc *r_rel; 3253 bfd *abfd; 3254 Elf_Internal_Rela *irel; 3255 { 3256 if (irel != NULL) 3257 { 3258 r_rel->rela = *irel; 3259 r_rel->abfd = abfd; 3260 r_rel->target_offset = r_reloc_get_target_offset (r_rel); 3261 } 3262 else 3263 memset (r_rel, 0, sizeof (r_reloc)); 3264 } 3265 3266 3267 static bfd_vma 3268 r_reloc_get_target_offset (r_rel) 3269 const r_reloc *r_rel; 3270 { 3271 bfd_vma target_offset; 3272 unsigned long r_symndx; 3273 3274 BFD_ASSERT (!r_reloc_is_const (r_rel)); 3275 r_symndx = ELF32_R_SYM (r_rel->rela.r_info); 3276 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx); 3277 return (target_offset + r_rel->rela.r_addend); 3278 } 3279 3280 3281 static struct elf_link_hash_entry * 3282 r_reloc_get_hash_entry (r_rel) 3283 const r_reloc *r_rel; 3284 { 3285 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info); 3286 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx); 3287 } 3288 3289 3290 static asection * 3291 r_reloc_get_section (r_rel) 3292 const r_reloc *r_rel; 3293 { 3294 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info); 3295 return get_elf_r_symndx_section (r_rel->abfd, r_symndx); 3296 } 3297 3298 3299 static bfd_boolean 3300 r_reloc_is_defined (r_rel) 3301 const r_reloc *r_rel; 3302 { 3303 asection *sec = r_reloc_get_section (r_rel); 3304 if (sec == bfd_abs_section_ptr 3305 || sec == bfd_com_section_ptr 3306 || sec == bfd_und_section_ptr) 3307 return FALSE; 3308 return TRUE; 3309 } 3310 3311 3312 /* source_reloc: relocations that reference literal sections. */ 3313 3314 /* To determine whether literals can be coalesced, we need to first 3315 record all the relocations that reference the literals. The 3316 source_reloc structure below is used for this purpose. The 3317 source_reloc entries are kept in a per-literal-section array, sorted 3318 by offset within the literal section (i.e., target offset). 3319 3320 The source_sec and r_rel.rela.r_offset fields identify the source of 3321 the relocation. The r_rel field records the relocation value, i.e., 3322 the offset of the literal being referenced. The opnd field is needed 3323 to determine the range of the immediate field to which the relocation 3324 applies, so we can determine whether another literal with the same 3325 value is within range. The is_null field is true when the relocation 3326 is being removed (e.g., when an L32R is being removed due to a CALLX 3327 that is converted to a direct CALL). */ 3328 3329 typedef struct source_reloc_struct source_reloc; 3330 3331 struct source_reloc_struct 3332 { 3333 asection *source_sec; 3334 r_reloc r_rel; 3335 xtensa_operand opnd; 3336 bfd_boolean is_null; 3337 }; 3338 3339 3340 static void init_source_reloc 3341 PARAMS ((source_reloc *, asection *, const r_reloc *, xtensa_operand)); 3342 static source_reloc *find_source_reloc 3343 PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *)); 3344 static int source_reloc_compare 3345 PARAMS ((const PTR, const PTR)); 3346 3347 3348 static void 3349 init_source_reloc (reloc, source_sec, r_rel, opnd) 3350 source_reloc *reloc; 3351 asection *source_sec; 3352 const r_reloc *r_rel; 3353 xtensa_operand opnd; 3354 { 3355 reloc->source_sec = source_sec; 3356 reloc->r_rel = *r_rel; 3357 reloc->opnd = opnd; 3358 reloc->is_null = FALSE; 3359 } 3360 3361 3362 /* Find the source_reloc for a particular source offset and relocation 3363 type. Note that the array is sorted by _target_ offset, so this is 3364 just a linear search. */ 3365 3366 static source_reloc * 3367 find_source_reloc (src_relocs, src_count, sec, irel) 3368 source_reloc *src_relocs; 3369 int src_count; 3370 asection *sec; 3371 Elf_Internal_Rela *irel; 3372 { 3373 int i; 3374 3375 for (i = 0; i < src_count; i++) 3376 { 3377 if (src_relocs[i].source_sec == sec 3378 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset 3379 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info) 3380 == ELF32_R_TYPE (irel->r_info))) 3381 return &src_relocs[i]; 3382 } 3383 3384 return NULL; 3385 } 3386 3387 3388 static int 3389 source_reloc_compare (ap, bp) 3390 const PTR ap; 3391 const PTR bp; 3392 { 3393 const source_reloc *a = (const source_reloc *) ap; 3394 const source_reloc *b = (const source_reloc *) bp; 3395 3396 return (a->r_rel.target_offset - b->r_rel.target_offset); 3397 } 3398 3399 3400 /* Literal values and value hash tables. */ 3401 3402 /* Literals with the same value can be coalesced. The literal_value 3403 structure records the value of a literal: the "r_rel" field holds the 3404 information from the relocation on the literal (if there is one) and 3405 the "value" field holds the contents of the literal word itself. 3406 3407 The value_map structure records a literal value along with the 3408 location of a literal holding that value. The value_map hash table 3409 is indexed by the literal value, so that we can quickly check if a 3410 particular literal value has been seen before and is thus a candidate 3411 for coalescing. */ 3412 3413 typedef struct literal_value_struct literal_value; 3414 typedef struct value_map_struct value_map; 3415 typedef struct value_map_hash_table_struct value_map_hash_table; 3416 3417 struct literal_value_struct 3418 { 3419 r_reloc r_rel; 3420 unsigned long value; 3421 }; 3422 3423 struct value_map_struct 3424 { 3425 literal_value val; /* The literal value. */ 3426 r_reloc loc; /* Location of the literal. */ 3427 value_map *next; 3428 }; 3429 3430 struct value_map_hash_table_struct 3431 { 3432 unsigned bucket_count; 3433 value_map **buckets; 3434 unsigned count; 3435 }; 3436 3437 3438 static bfd_boolean is_same_value 3439 PARAMS ((const literal_value *, const literal_value *, bfd_boolean)); 3440 static value_map_hash_table *value_map_hash_table_init 3441 PARAMS ((void)); 3442 static unsigned hash_literal_value 3443 PARAMS ((const literal_value *)); 3444 static unsigned hash_bfd_vma 3445 PARAMS ((bfd_vma)); 3446 static value_map *get_cached_value 3447 PARAMS ((value_map_hash_table *, const literal_value *, bfd_boolean)); 3448 static value_map *add_value_map 3449 PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *, 3450 bfd_boolean)); 3451 3452 3453 static bfd_boolean 3454 is_same_value (src1, src2, final_static_link) 3455 const literal_value *src1; 3456 const literal_value *src2; 3457 bfd_boolean final_static_link; 3458 { 3459 struct elf_link_hash_entry *h1, *h2; 3460 3461 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel)) 3462 return FALSE; 3463 3464 if (r_reloc_is_const (&src1->r_rel)) 3465 return (src1->value == src2->value); 3466 3467 if (ELF32_R_TYPE (src1->r_rel.rela.r_info) 3468 != ELF32_R_TYPE (src2->r_rel.rela.r_info)) 3469 return FALSE; 3470 3471 if (r_reloc_get_target_offset (&src1->r_rel) 3472 != r_reloc_get_target_offset (&src2->r_rel)) 3473 return FALSE; 3474 3475 if (src1->value != src2->value) 3476 return FALSE; 3477 3478 /* Now check for the same section (if defined) or the same elf_hash 3479 (if undefined or weak). */ 3480 h1 = r_reloc_get_hash_entry (&src1->r_rel); 3481 h2 = r_reloc_get_hash_entry (&src2->r_rel); 3482 if (r_reloc_is_defined (&src1->r_rel) 3483 && (final_static_link 3484 || ((!h1 || h1->root.type != bfd_link_hash_defweak) 3485 && (!h2 || h2->root.type != bfd_link_hash_defweak)))) 3486 { 3487 if (r_reloc_get_section (&src1->r_rel) 3488 != r_reloc_get_section (&src2->r_rel)) 3489 return FALSE; 3490 } 3491 else 3492 { 3493 /* Require that the hash entries (i.e., symbols) be identical. */ 3494 if (h1 != h2 || h1 == 0) 3495 return FALSE; 3496 } 3497 3498 return TRUE; 3499 } 3500 3501 3502 /* Must be power of 2. */ 3503 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024 3504 3505 static value_map_hash_table * 3506 value_map_hash_table_init () 3507 { 3508 value_map_hash_table *values; 3509 3510 values = (value_map_hash_table *) 3511 bfd_malloc (sizeof (value_map_hash_table)); 3512 3513 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT; 3514 values->count = 0; 3515 values->buckets = (value_map **) 3516 bfd_zmalloc (sizeof (value_map *) * values->bucket_count); 3517 3518 return values; 3519 } 3520 3521 3522 static unsigned 3523 hash_bfd_vma (val) 3524 bfd_vma val; 3525 { 3526 return (val >> 2) + (val >> 10); 3527 } 3528 3529 3530 static unsigned 3531 hash_literal_value (src) 3532 const literal_value *src; 3533 { 3534 unsigned hash_val; 3535 3536 if (r_reloc_is_const (&src->r_rel)) 3537 return hash_bfd_vma (src->value); 3538 3539 hash_val = (hash_bfd_vma (r_reloc_get_target_offset (&src->r_rel)) 3540 + hash_bfd_vma (src->value)); 3541 3542 /* Now check for the same section and the same elf_hash. */ 3543 if (r_reloc_is_defined (&src->r_rel)) 3544 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_section (&src->r_rel)); 3545 else 3546 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_hash_entry (&src->r_rel)); 3547 3548 return hash_val; 3549 } 3550 3551 3552 /* Check if the specified literal_value has been seen before. */ 3553 3554 static value_map * 3555 get_cached_value (map, val, final_static_link) 3556 value_map_hash_table *map; 3557 const literal_value *val; 3558 bfd_boolean final_static_link; 3559 { 3560 value_map *map_e; 3561 value_map *bucket; 3562 unsigned idx; 3563 3564 idx = hash_literal_value (val); 3565 idx = idx & (map->bucket_count - 1); 3566 bucket = map->buckets[idx]; 3567 for (map_e = bucket; map_e; map_e = map_e->next) 3568 { 3569 if (is_same_value (&map_e->val, val, final_static_link)) 3570 return map_e; 3571 } 3572 return NULL; 3573 } 3574 3575 3576 /* Record a new literal value. It is illegal to call this if VALUE 3577 already has an entry here. */ 3578 3579 static value_map * 3580 add_value_map (map, val, loc, final_static_link) 3581 value_map_hash_table *map; 3582 const literal_value *val; 3583 const r_reloc *loc; 3584 bfd_boolean final_static_link; 3585 { 3586 value_map **bucket_p; 3587 unsigned idx; 3588 3589 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map)); 3590 3591 BFD_ASSERT (get_cached_value (map, val, final_static_link) == NULL); 3592 val_e->val = *val; 3593 val_e->loc = *loc; 3594 3595 idx = hash_literal_value (val); 3596 idx = idx & (map->bucket_count - 1); 3597 bucket_p = &map->buckets[idx]; 3598 3599 val_e->next = *bucket_p; 3600 *bucket_p = val_e; 3601 map->count++; 3602 /* FIXME: consider resizing the hash table if we get too many entries */ 3603 3604 return val_e; 3605 } 3606 3607 3608 /* Lists of literals being coalesced or removed. */ 3609 3610 /* In the usual case, the literal identified by "from" is being 3611 coalesced with another literal identified by "to". If the literal is 3612 unused and is being removed altogether, "to.abfd" will be NULL. 3613 The removed_literal entries are kept on a per-section list, sorted 3614 by the "from" offset field. */ 3615 3616 typedef struct removed_literal_struct removed_literal; 3617 typedef struct removed_literal_list_struct removed_literal_list; 3618 3619 struct removed_literal_struct 3620 { 3621 r_reloc from; 3622 r_reloc to; 3623 removed_literal *next; 3624 }; 3625 3626 struct removed_literal_list_struct 3627 { 3628 removed_literal *head; 3629 removed_literal *tail; 3630 }; 3631 3632 3633 static void add_removed_literal 3634 PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *)); 3635 static removed_literal *find_removed_literal 3636 PARAMS ((removed_literal_list *, bfd_vma)); 3637 static bfd_vma offset_with_removed_literals 3638 PARAMS ((removed_literal_list *, bfd_vma)); 3639 3640 3641 /* Record that the literal at "from" is being removed. If "to" is not 3642 NULL, the "from" literal is being coalesced with the "to" literal. */ 3643 3644 static void 3645 add_removed_literal (removed_list, from, to) 3646 removed_literal_list *removed_list; 3647 const r_reloc *from; 3648 const r_reloc *to; 3649 { 3650 removed_literal *r, *new_r, *next_r; 3651 3652 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal)); 3653 3654 new_r->from = *from; 3655 if (to) 3656 new_r->to = *to; 3657 else 3658 new_r->to.abfd = NULL; 3659 new_r->next = NULL; 3660 3661 r = removed_list->head; 3662 if (r == NULL) 3663 { 3664 removed_list->head = new_r; 3665 removed_list->tail = new_r; 3666 } 3667 /* Special check for common case of append. */ 3668 else if (removed_list->tail->from.target_offset < from->target_offset) 3669 { 3670 removed_list->tail->next = new_r; 3671 removed_list->tail = new_r; 3672 } 3673 else 3674 { 3675 while (r->from.target_offset < from->target_offset 3676 && r->next != NULL) 3677 { 3678 r = r->next; 3679 } 3680 next_r = r->next; 3681 r->next = new_r; 3682 new_r->next = next_r; 3683 if (next_r == NULL) 3684 removed_list->tail = new_r; 3685 } 3686 } 3687 3688 3689 /* Check if the list of removed literals contains an entry for the 3690 given address. Return the entry if found. */ 3691 3692 static removed_literal * 3693 find_removed_literal (removed_list, addr) 3694 removed_literal_list *removed_list; 3695 bfd_vma addr; 3696 { 3697 removed_literal *r = removed_list->head; 3698 while (r && r->from.target_offset < addr) 3699 r = r->next; 3700 if (r && r->from.target_offset == addr) 3701 return r; 3702 return NULL; 3703 } 3704 3705 3706 /* Adjust an offset in a section to compensate for literals that are 3707 being removed. Search the list of removed literals and subtract 3708 4 bytes for every removed literal prior to the given address. */ 3709 3710 static bfd_vma 3711 offset_with_removed_literals (removed_list, addr) 3712 removed_literal_list *removed_list; 3713 bfd_vma addr; 3714 { 3715 removed_literal *r = removed_list->head; 3716 unsigned num_bytes = 0; 3717 3718 if (r == NULL) 3719 return addr; 3720 3721 while (r && r->from.target_offset <= addr) 3722 { 3723 num_bytes += 4; 3724 r = r->next; 3725 } 3726 if (num_bytes > addr) 3727 return 0; 3728 return (addr - num_bytes); 3729 } 3730 3731 3732 /* Coalescing literals may require a relocation to refer to a section in 3733 a different input file, but the standard relocation information 3734 cannot express that. Instead, the reloc_bfd_fix structures are used 3735 to "fix" the relocations that refer to sections in other input files. 3736 These structures are kept on per-section lists. The "src_type" field 3737 records the relocation type in case there are multiple relocations on 3738 the same location. FIXME: This is ugly; an alternative might be to 3739 add new symbols with the "owner" field to some other input file. */ 3740 3741 typedef struct reloc_bfd_fix_struct reloc_bfd_fix; 3742 3743 struct reloc_bfd_fix_struct 3744 { 3745 asection *src_sec; 3746 bfd_vma src_offset; 3747 unsigned src_type; /* Relocation type. */ 3748 3749 bfd *target_abfd; 3750 asection *target_sec; 3751 bfd_vma target_offset; 3752 3753 reloc_bfd_fix *next; 3754 }; 3755 3756 3757 static reloc_bfd_fix *reloc_bfd_fix_init 3758 PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma)); 3759 static reloc_bfd_fix *get_bfd_fix 3760 PARAMS ((reloc_bfd_fix *, asection *, bfd_vma, unsigned)); 3761 3762 3763 static reloc_bfd_fix * 3764 reloc_bfd_fix_init (src_sec, src_offset, src_type, 3765 target_abfd, target_sec, target_offset) 3766 asection *src_sec; 3767 bfd_vma src_offset; 3768 unsigned src_type; 3769 bfd *target_abfd; 3770 asection *target_sec; 3771 bfd_vma target_offset; 3772 { 3773 reloc_bfd_fix *fix; 3774 3775 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix)); 3776 fix->src_sec = src_sec; 3777 fix->src_offset = src_offset; 3778 fix->src_type = src_type; 3779 fix->target_abfd = target_abfd; 3780 fix->target_sec = target_sec; 3781 fix->target_offset = target_offset; 3782 3783 return fix; 3784 } 3785 3786 3787 static reloc_bfd_fix * 3788 get_bfd_fix (fix_list, sec, offset, type) 3789 reloc_bfd_fix *fix_list; 3790 asection *sec; 3791 bfd_vma offset; 3792 unsigned type; 3793 { 3794 reloc_bfd_fix *r; 3795 3796 for (r = fix_list; r != NULL; r = r->next) 3797 { 3798 if (r->src_sec == sec 3799 && r->src_offset == offset 3800 && r->src_type == type) 3801 return r; 3802 } 3803 return NULL; 3804 } 3805 3806 3807 /* Per-section data for relaxation. */ 3808 3809 struct xtensa_relax_info_struct 3810 { 3811 bfd_boolean is_relaxable_literal_section; 3812 int visited; /* Number of times visited. */ 3813 3814 source_reloc *src_relocs; /* Array[src_count]. */ 3815 int src_count; 3816 int src_next; /* Next src_relocs entry to assign. */ 3817 3818 removed_literal_list removed_list; 3819 3820 reloc_bfd_fix *fix_list; 3821 }; 3822 3823 struct elf_xtensa_section_data 3824 { 3825 struct bfd_elf_section_data elf; 3826 xtensa_relax_info relax_info; 3827 }; 3828 3829 static void init_xtensa_relax_info 3830 PARAMS ((asection *)); 3831 static xtensa_relax_info *get_xtensa_relax_info 3832 PARAMS ((asection *)); 3833 static void add_fix 3834 PARAMS ((asection *, reloc_bfd_fix *)); 3835 3836 3837 static bfd_boolean 3838 elf_xtensa_new_section_hook (abfd, sec) 3839 bfd *abfd; 3840 asection *sec; 3841 { 3842 struct elf_xtensa_section_data *sdata; 3843 bfd_size_type amt = sizeof (*sdata); 3844 3845 sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt); 3846 if (sdata == NULL) 3847 return FALSE; 3848 sec->used_by_bfd = (PTR) sdata; 3849 3850 return _bfd_elf_new_section_hook (abfd, sec); 3851 } 3852 3853 3854 static void 3855 init_xtensa_relax_info (sec) 3856 asection *sec; 3857 { 3858 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec); 3859 3860 relax_info->is_relaxable_literal_section = FALSE; 3861 relax_info->visited = 0; 3862 3863 relax_info->src_relocs = NULL; 3864 relax_info->src_count = 0; 3865 relax_info->src_next = 0; 3866 3867 relax_info->removed_list.head = NULL; 3868 relax_info->removed_list.tail = NULL; 3869 3870 relax_info->fix_list = NULL; 3871 } 3872 3873 3874 static xtensa_relax_info * 3875 get_xtensa_relax_info (sec) 3876 asection *sec; 3877 { 3878 struct elf_xtensa_section_data *section_data; 3879 3880 /* No info available if no section or if it is an output section. */ 3881 if (!sec || sec == sec->output_section) 3882 return NULL; 3883 3884 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec); 3885 return §ion_data->relax_info; 3886 } 3887 3888 3889 static void 3890 add_fix (src_sec, fix) 3891 asection *src_sec; 3892 reloc_bfd_fix *fix; 3893 { 3894 xtensa_relax_info *relax_info; 3895 3896 relax_info = get_xtensa_relax_info (src_sec); 3897 fix->next = relax_info->fix_list; 3898 relax_info->fix_list = fix; 3899 } 3900 3901 3902 /* Access to internal relocations, section contents and symbols. */ 3903 3904 /* During relaxation, we need to modify relocations, section contents, 3905 and symbol definitions, and we need to keep the original values from 3906 being reloaded from the input files, i.e., we need to "pin" the 3907 modified values in memory. We also want to continue to observe the 3908 setting of the "keep-memory" flag. The following functions wrap the 3909 standard BFD functions to take care of this for us. */ 3910 3911 static Elf_Internal_Rela * 3912 retrieve_internal_relocs (abfd, sec, keep_memory) 3913 bfd *abfd; 3914 asection *sec; 3915 bfd_boolean keep_memory; 3916 { 3917 Elf_Internal_Rela *internal_relocs; 3918 3919 if ((sec->flags & SEC_LINKER_CREATED) != 0) 3920 return NULL; 3921 3922 internal_relocs = elf_section_data (sec)->relocs; 3923 if (internal_relocs == NULL) 3924 internal_relocs = (_bfd_elf_link_read_relocs 3925 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 3926 keep_memory)); 3927 return internal_relocs; 3928 } 3929 3930 3931 static void 3932 pin_internal_relocs (sec, internal_relocs) 3933 asection *sec; 3934 Elf_Internal_Rela *internal_relocs; 3935 { 3936 elf_section_data (sec)->relocs = internal_relocs; 3937 } 3938 3939 3940 static void 3941 release_internal_relocs (sec, internal_relocs) 3942 asection *sec; 3943 Elf_Internal_Rela *internal_relocs; 3944 { 3945 if (internal_relocs 3946 && elf_section_data (sec)->relocs != internal_relocs) 3947 free (internal_relocs); 3948 } 3949 3950 3951 static bfd_byte * 3952 retrieve_contents (abfd, sec, keep_memory) 3953 bfd *abfd; 3954 asection *sec; 3955 bfd_boolean keep_memory; 3956 { 3957 bfd_byte *contents; 3958 3959 contents = elf_section_data (sec)->this_hdr.contents; 3960 3961 if (contents == NULL && sec->_raw_size != 0) 3962 { 3963 contents = (bfd_byte *) bfd_malloc (sec->_raw_size); 3964 if (contents != NULL) 3965 { 3966 if (! bfd_get_section_contents (abfd, sec, contents, 3967 (file_ptr) 0, sec->_raw_size)) 3968 { 3969 free (contents); 3970 return NULL; 3971 } 3972 if (keep_memory) 3973 elf_section_data (sec)->this_hdr.contents = contents; 3974 } 3975 } 3976 return contents; 3977 } 3978 3979 3980 static void 3981 pin_contents (sec, contents) 3982 asection *sec; 3983 bfd_byte *contents; 3984 { 3985 elf_section_data (sec)->this_hdr.contents = contents; 3986 } 3987 3988 3989 static void 3990 release_contents (sec, contents) 3991 asection *sec; 3992 bfd_byte *contents; 3993 { 3994 if (contents && 3995 elf_section_data (sec)->this_hdr.contents != contents) 3996 free (contents); 3997 } 3998 3999 4000 static Elf_Internal_Sym * 4001 retrieve_local_syms (input_bfd) 4002 bfd *input_bfd; 4003 { 4004 Elf_Internal_Shdr *symtab_hdr; 4005 Elf_Internal_Sym *isymbuf; 4006 size_t locsymcount; 4007 4008 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 4009 locsymcount = symtab_hdr->sh_info; 4010 4011 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 4012 if (isymbuf == NULL && locsymcount != 0) 4013 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0, 4014 NULL, NULL, NULL); 4015 4016 /* Save the symbols for this input file so they won't be read again. */ 4017 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents) 4018 symtab_hdr->contents = (unsigned char *) isymbuf; 4019 4020 return isymbuf; 4021 } 4022 4023 4024 /* Code for link-time relaxation. */ 4025 4026 /* Local helper functions. */ 4027 static bfd_boolean analyze_relocations 4028 PARAMS ((struct bfd_link_info *)); 4029 static bfd_boolean find_relaxable_sections 4030 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); 4031 static bfd_boolean collect_source_relocs 4032 PARAMS ((bfd *, asection *, struct bfd_link_info *)); 4033 static bfd_boolean is_resolvable_asm_expansion 4034 PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, 4035 struct bfd_link_info *, bfd_boolean *)); 4036 static bfd_boolean remove_literals 4037 PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *)); 4038 static bfd_boolean relax_section 4039 PARAMS ((bfd *, asection *, struct bfd_link_info *)); 4040 static bfd_boolean relax_property_section 4041 PARAMS ((bfd *, asection *, struct bfd_link_info *)); 4042 static bfd_boolean relax_section_symbols 4043 PARAMS ((bfd *, asection *)); 4044 static bfd_boolean relocations_reach 4045 PARAMS ((source_reloc *, int, const r_reloc *)); 4046 static void translate_reloc 4047 PARAMS ((const r_reloc *, r_reloc *)); 4048 static Elf_Internal_Rela *get_irel_at_offset 4049 PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma)); 4050 static Elf_Internal_Rela *find_associated_l32r_irel 4051 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *, 4052 Elf_Internal_Rela *)); 4053 static void shrink_dynamic_reloc_sections 4054 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *)); 4055 4056 4057 static bfd_boolean 4058 elf_xtensa_relax_section (abfd, sec, link_info, again) 4059 bfd *abfd; 4060 asection *sec; 4061 struct bfd_link_info *link_info; 4062 bfd_boolean *again; 4063 { 4064 static value_map_hash_table *values = NULL; 4065 xtensa_relax_info *relax_info; 4066 4067 if (!values) 4068 { 4069 /* Do some overall initialization for relaxation. */ 4070 values = value_map_hash_table_init (); 4071 relaxing_section = TRUE; 4072 if (!analyze_relocations (link_info)) 4073 return FALSE; 4074 } 4075 *again = FALSE; 4076 4077 /* Don't mess with linker-created sections. */ 4078 if ((sec->flags & SEC_LINKER_CREATED) != 0) 4079 return TRUE; 4080 4081 relax_info = get_xtensa_relax_info (sec); 4082 BFD_ASSERT (relax_info != NULL); 4083 4084 switch (relax_info->visited) 4085 { 4086 case 0: 4087 /* Note: It would be nice to fold this pass into 4088 analyze_relocations, but it is important for this step that the 4089 sections be examined in link order. */ 4090 if (!remove_literals (abfd, sec, link_info, values)) 4091 return FALSE; 4092 *again = TRUE; 4093 break; 4094 4095 case 1: 4096 if (!relax_section (abfd, sec, link_info)) 4097 return FALSE; 4098 *again = TRUE; 4099 break; 4100 4101 case 2: 4102 if (!relax_section_symbols (abfd, sec)) 4103 return FALSE; 4104 break; 4105 } 4106 4107 relax_info->visited++; 4108 return TRUE; 4109 } 4110 4111 /* Initialization for relaxation. */ 4112 4113 /* This function is called once at the start of relaxation. It scans 4114 all the input sections and marks the ones that are relaxable (i.e., 4115 literal sections with L32R relocations against them). It then 4116 collect source_reloc information for all the relocations against 4117 those relaxable sections. */ 4118 4119 static bfd_boolean 4120 analyze_relocations (link_info) 4121 struct bfd_link_info *link_info; 4122 { 4123 bfd *abfd; 4124 asection *sec; 4125 bfd_boolean is_relaxable = FALSE; 4126 4127 /* Initialize the per-section relaxation info. */ 4128 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) 4129 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4130 { 4131 init_xtensa_relax_info (sec); 4132 } 4133 4134 /* Mark relaxable sections (and count relocations against each one). */ 4135 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) 4136 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4137 { 4138 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable)) 4139 return FALSE; 4140 } 4141 4142 /* Bail out if there are no relaxable sections. */ 4143 if (!is_relaxable) 4144 return TRUE; 4145 4146 /* Allocate space for source_relocs. */ 4147 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) 4148 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4149 { 4150 xtensa_relax_info *relax_info; 4151 4152 relax_info = get_xtensa_relax_info (sec); 4153 if (relax_info->is_relaxable_literal_section) 4154 { 4155 relax_info->src_relocs = (source_reloc *) 4156 bfd_malloc (relax_info->src_count * sizeof (source_reloc)); 4157 } 4158 } 4159 4160 /* Collect info on relocations against each relaxable section. */ 4161 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) 4162 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4163 { 4164 if (!collect_source_relocs (abfd, sec, link_info)) 4165 return FALSE; 4166 } 4167 4168 return TRUE; 4169 } 4170 4171 4172 /* Find all the literal sections that might be relaxed. The motivation 4173 for this pass is that collect_source_relocs() needs to record _all_ 4174 the relocations that target each relaxable section. That is 4175 expensive and unnecessary unless the target section is actually going 4176 to be relaxed. This pass identifies all such sections by checking if 4177 they have L32Rs pointing to them. In the process, the total number 4178 of relocations targeting each section is also counted so that we 4179 know how much space to allocate for source_relocs against each 4180 relaxable literal section. */ 4181 4182 static bfd_boolean 4183 find_relaxable_sections (abfd, sec, link_info, is_relaxable_p) 4184 bfd *abfd; 4185 asection *sec; 4186 struct bfd_link_info *link_info; 4187 bfd_boolean *is_relaxable_p; 4188 { 4189 Elf_Internal_Rela *internal_relocs; 4190 bfd_byte *contents; 4191 bfd_boolean ok = TRUE; 4192 unsigned i; 4193 4194 internal_relocs = retrieve_internal_relocs (abfd, sec, 4195 link_info->keep_memory); 4196 if (internal_relocs == NULL) 4197 return ok; 4198 4199 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 4200 if (contents == NULL && sec->_raw_size != 0) 4201 { 4202 ok = FALSE; 4203 goto error_return; 4204 } 4205 4206 for (i = 0; i < sec->reloc_count; i++) 4207 { 4208 Elf_Internal_Rela *irel = &internal_relocs[i]; 4209 r_reloc r_rel; 4210 asection *target_sec; 4211 xtensa_relax_info *target_relax_info; 4212 4213 r_reloc_init (&r_rel, abfd, irel); 4214 4215 target_sec = r_reloc_get_section (&r_rel); 4216 target_relax_info = get_xtensa_relax_info (target_sec); 4217 if (!target_relax_info) 4218 continue; 4219 4220 /* Count relocations against the target section. */ 4221 target_relax_info->src_count++; 4222 4223 if (is_literal_section (target_sec) 4224 && is_l32r_relocation (sec, contents, irel) 4225 && r_reloc_is_defined (&r_rel)) 4226 { 4227 /* Mark the target section as relaxable. */ 4228 target_relax_info->is_relaxable_literal_section = TRUE; 4229 *is_relaxable_p = TRUE; 4230 } 4231 } 4232 4233 error_return: 4234 release_contents (sec, contents); 4235 release_internal_relocs (sec, internal_relocs); 4236 return ok; 4237 } 4238 4239 4240 /* Record _all_ the relocations that point to relaxable literal 4241 sections, and get rid of ASM_EXPAND relocs by either converting them 4242 to ASM_SIMPLIFY or by removing them. */ 4243 4244 static bfd_boolean 4245 collect_source_relocs (abfd, sec, link_info) 4246 bfd *abfd; 4247 asection *sec; 4248 struct bfd_link_info *link_info; 4249 { 4250 Elf_Internal_Rela *internal_relocs; 4251 bfd_byte *contents; 4252 bfd_boolean ok = TRUE; 4253 unsigned i; 4254 4255 internal_relocs = retrieve_internal_relocs (abfd, sec, 4256 link_info->keep_memory); 4257 if (internal_relocs == NULL) 4258 return ok; 4259 4260 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 4261 if (contents == NULL && sec->_raw_size != 0) 4262 { 4263 ok = FALSE; 4264 goto error_return; 4265 } 4266 4267 /* Record relocations against relaxable literal sections. */ 4268 for (i = 0; i < sec->reloc_count; i++) 4269 { 4270 Elf_Internal_Rela *irel = &internal_relocs[i]; 4271 r_reloc r_rel; 4272 asection *target_sec; 4273 xtensa_relax_info *target_relax_info; 4274 4275 r_reloc_init (&r_rel, abfd, irel); 4276 4277 target_sec = r_reloc_get_section (&r_rel); 4278 target_relax_info = get_xtensa_relax_info (target_sec); 4279 4280 if (target_relax_info 4281 && target_relax_info->is_relaxable_literal_section) 4282 { 4283 xtensa_opcode opcode; 4284 xtensa_operand opnd; 4285 source_reloc *s_reloc; 4286 int src_next; 4287 4288 src_next = target_relax_info->src_next++; 4289 s_reloc = &target_relax_info->src_relocs[src_next]; 4290 4291 opcode = get_relocation_opcode (sec, contents, irel); 4292 if (opcode == XTENSA_UNDEFINED) 4293 opnd = NULL; 4294 else 4295 opnd = xtensa_get_operand (xtensa_default_isa, opcode, 4296 get_relocation_opnd (irel)); 4297 4298 init_source_reloc (s_reloc, sec, &r_rel, opnd); 4299 } 4300 } 4301 4302 /* Now get rid of ASM_EXPAND relocations. At this point, the 4303 src_relocs array for the target literal section may still be 4304 incomplete, but it must at least contain the entries for the L32R 4305 relocations associated with ASM_EXPANDs because they were just 4306 added in the preceding loop over the relocations. */ 4307 4308 for (i = 0; i < sec->reloc_count; i++) 4309 { 4310 Elf_Internal_Rela *irel = &internal_relocs[i]; 4311 bfd_boolean is_reachable; 4312 4313 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info, 4314 &is_reachable)) 4315 continue; 4316 4317 if (is_reachable) 4318 { 4319 Elf_Internal_Rela *l32r_irel; 4320 r_reloc r_rel; 4321 asection *target_sec; 4322 xtensa_relax_info *target_relax_info; 4323 4324 /* Mark the source_reloc for the L32R so that it will be 4325 removed in remove_literals(), along with the associated 4326 literal. */ 4327 l32r_irel = find_associated_l32r_irel (sec, contents, 4328 irel, internal_relocs); 4329 if (l32r_irel == NULL) 4330 continue; 4331 4332 r_reloc_init (&r_rel, abfd, l32r_irel); 4333 4334 target_sec = r_reloc_get_section (&r_rel); 4335 target_relax_info = get_xtensa_relax_info (target_sec); 4336 4337 if (target_relax_info 4338 && target_relax_info->is_relaxable_literal_section) 4339 { 4340 source_reloc *s_reloc; 4341 4342 /* Search the source_relocs for the entry corresponding to 4343 the l32r_irel. Note: The src_relocs array is not yet 4344 sorted, but it wouldn't matter anyway because we're 4345 searching by source offset instead of target offset. */ 4346 s_reloc = find_source_reloc (target_relax_info->src_relocs, 4347 target_relax_info->src_next, 4348 sec, l32r_irel); 4349 BFD_ASSERT (s_reloc); 4350 s_reloc->is_null = TRUE; 4351 } 4352 4353 /* Convert this reloc to ASM_SIMPLIFY. */ 4354 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4355 R_XTENSA_ASM_SIMPLIFY); 4356 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 4357 4358 pin_internal_relocs (sec, internal_relocs); 4359 } 4360 else 4361 { 4362 /* It is resolvable but doesn't reach. We resolve now 4363 by eliminating the relocation -- the call will remain 4364 expanded into L32R/CALLX. */ 4365 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 4366 pin_internal_relocs (sec, internal_relocs); 4367 } 4368 } 4369 4370 error_return: 4371 release_contents (sec, contents); 4372 release_internal_relocs (sec, internal_relocs); 4373 return ok; 4374 } 4375 4376 4377 /* Return TRUE if the asm expansion can be resolved. Generally it can 4378 be resolved on a final link or when a partial link locates it in the 4379 same section as the target. Set "is_reachable" flag if the target of 4380 the call is within the range of a direct call, given the current VMA 4381 for this section and the target section. */ 4382 4383 bfd_boolean 4384 is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info, 4385 is_reachable_p) 4386 bfd *abfd; 4387 asection *sec; 4388 bfd_byte *contents; 4389 Elf_Internal_Rela *irel; 4390 struct bfd_link_info *link_info; 4391 bfd_boolean *is_reachable_p; 4392 { 4393 asection *target_sec; 4394 bfd_vma target_offset; 4395 r_reloc r_rel; 4396 xtensa_opcode opcode, direct_call_opcode; 4397 bfd_vma self_address; 4398 bfd_vma dest_address; 4399 4400 *is_reachable_p = FALSE; 4401 4402 if (contents == NULL) 4403 return FALSE; 4404 4405 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND) 4406 return FALSE; 4407 4408 opcode = get_expanded_call_opcode (contents + irel->r_offset, 4409 sec->_raw_size - irel->r_offset); 4410 4411 direct_call_opcode = swap_callx_for_call_opcode (opcode); 4412 if (direct_call_opcode == XTENSA_UNDEFINED) 4413 return FALSE; 4414 4415 /* Check and see that the target resolves. */ 4416 r_reloc_init (&r_rel, abfd, irel); 4417 if (!r_reloc_is_defined (&r_rel)) 4418 return FALSE; 4419 4420 target_sec = r_reloc_get_section (&r_rel); 4421 target_offset = r_reloc_get_target_offset (&r_rel); 4422 4423 /* If the target is in a shared library, then it doesn't reach. This 4424 isn't supposed to come up because the compiler should never generate 4425 non-PIC calls on systems that use shared libraries, but the linker 4426 shouldn't crash regardless. */ 4427 if (!target_sec->output_section) 4428 return FALSE; 4429 4430 /* For relocatable sections, we can only simplify when the output 4431 section of the target is the same as the output section of the 4432 source. */ 4433 if (link_info->relocatable 4434 && (target_sec->output_section != sec->output_section)) 4435 return FALSE; 4436 4437 self_address = (sec->output_section->vma 4438 + sec->output_offset + irel->r_offset + 3); 4439 dest_address = (target_sec->output_section->vma 4440 + target_sec->output_offset + target_offset); 4441 4442 *is_reachable_p = pcrel_reloc_fits 4443 (xtensa_get_operand (xtensa_default_isa, direct_call_opcode, 0), 4444 self_address, dest_address); 4445 4446 if ((self_address >> CALL_SEGMENT_BITS) != 4447 (dest_address >> CALL_SEGMENT_BITS)) 4448 return FALSE; 4449 4450 return TRUE; 4451 } 4452 4453 4454 static Elf_Internal_Rela * 4455 find_associated_l32r_irel (sec, contents, other_irel, internal_relocs) 4456 asection *sec; 4457 bfd_byte *contents; 4458 Elf_Internal_Rela *other_irel; 4459 Elf_Internal_Rela *internal_relocs; 4460 { 4461 unsigned i; 4462 4463 for (i = 0; i < sec->reloc_count; i++) 4464 { 4465 Elf_Internal_Rela *irel = &internal_relocs[i]; 4466 4467 if (irel == other_irel) 4468 continue; 4469 if (irel->r_offset != other_irel->r_offset) 4470 continue; 4471 if (is_l32r_relocation (sec, contents, irel)) 4472 return irel; 4473 } 4474 4475 return NULL; 4476 } 4477 4478 /* First relaxation pass. */ 4479 4480 /* If the section is relaxable (i.e., a literal section), check each 4481 literal to see if it has the same value as another literal that has 4482 already been seen, either in the current section or a previous one. 4483 If so, add an entry to the per-section list of removed literals. The 4484 actual changes are deferred until the next pass. */ 4485 4486 static bfd_boolean 4487 remove_literals (abfd, sec, link_info, values) 4488 bfd *abfd; 4489 asection *sec; 4490 struct bfd_link_info *link_info; 4491 value_map_hash_table *values; 4492 { 4493 xtensa_relax_info *relax_info; 4494 bfd_byte *contents; 4495 Elf_Internal_Rela *internal_relocs; 4496 source_reloc *src_relocs; 4497 bfd_boolean final_static_link; 4498 bfd_boolean ok = TRUE; 4499 int i; 4500 4501 /* Do nothing if it is not a relaxable literal section. */ 4502 relax_info = get_xtensa_relax_info (sec); 4503 BFD_ASSERT (relax_info); 4504 4505 if (!relax_info->is_relaxable_literal_section) 4506 return ok; 4507 4508 internal_relocs = retrieve_internal_relocs (abfd, sec, 4509 link_info->keep_memory); 4510 4511 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 4512 if (contents == NULL && sec->_raw_size != 0) 4513 { 4514 ok = FALSE; 4515 goto error_return; 4516 } 4517 4518 final_static_link = 4519 (!link_info->relocatable 4520 && !elf_hash_table (link_info)->dynamic_sections_created); 4521 4522 /* Sort the source_relocs by target offset. */ 4523 src_relocs = relax_info->src_relocs; 4524 qsort (src_relocs, relax_info->src_count, 4525 sizeof (source_reloc), source_reloc_compare); 4526 4527 for (i = 0; i < relax_info->src_count; i++) 4528 { 4529 source_reloc *rel; 4530 Elf_Internal_Rela *irel = NULL; 4531 literal_value val; 4532 value_map *val_map; 4533 4534 rel = &src_relocs[i]; 4535 irel = get_irel_at_offset (sec, internal_relocs, 4536 rel->r_rel.target_offset); 4537 4538 /* If the target_offset for this relocation is the same as the 4539 previous relocation, then we've already considered whether the 4540 literal can be coalesced. Skip to the next one.... */ 4541 if (i != 0 && (src_relocs[i-1].r_rel.target_offset 4542 == rel->r_rel.target_offset)) 4543 continue; 4544 4545 /* Check if the relocation was from an L32R that is being removed 4546 because a CALLX was converted to a direct CALL, and check if 4547 there are no other relocations to the literal. */ 4548 if (rel->is_null 4549 && (i == relax_info->src_count - 1 4550 || (src_relocs[i+1].r_rel.target_offset 4551 != rel->r_rel.target_offset))) 4552 { 4553 /* Mark the unused literal so that it will be removed. */ 4554 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL); 4555 4556 /* Zero out the relocation on this literal location. */ 4557 if (irel) 4558 { 4559 if (elf_hash_table (link_info)->dynamic_sections_created) 4560 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel); 4561 4562 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 4563 } 4564 4565 continue; 4566 } 4567 4568 /* Find the literal value. */ 4569 r_reloc_init (&val.r_rel, abfd, irel); 4570 BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size); 4571 val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset); 4572 4573 /* Check if we've seen another literal with the same value. */ 4574 val_map = get_cached_value (values, &val, final_static_link); 4575 if (val_map != NULL) 4576 { 4577 /* First check that THIS and all the other relocs to this 4578 literal will FIT if we move them to the new address. */ 4579 4580 if (relocations_reach (rel, relax_info->src_count - i, 4581 &val_map->loc)) 4582 { 4583 /* Mark that the literal will be coalesced. */ 4584 add_removed_literal (&relax_info->removed_list, 4585 &rel->r_rel, &val_map->loc); 4586 } 4587 else 4588 { 4589 /* Relocations do not reach -- do not remove this literal. */ 4590 val_map->loc = rel->r_rel; 4591 } 4592 } 4593 else 4594 { 4595 /* This is the first time we've seen this literal value. */ 4596 BFD_ASSERT (sec == r_reloc_get_section (&rel->r_rel)); 4597 add_value_map (values, &val, &rel->r_rel, final_static_link); 4598 } 4599 } 4600 4601 error_return: 4602 release_contents (sec, contents); 4603 release_internal_relocs (sec, internal_relocs); 4604 return ok; 4605 } 4606 4607 4608 /* Check if the original relocations (presumably on L32R instructions) 4609 identified by reloc[0..N] can be changed to reference the literal 4610 identified by r_rel. If r_rel is out of range for any of the 4611 original relocations, then we don't want to coalesce the original 4612 literal with the one at r_rel. We only check reloc[0..N], where the 4613 offsets are all the same as for reloc[0] (i.e., they're all 4614 referencing the same literal) and where N is also bounded by the 4615 number of remaining entries in the "reloc" array. The "reloc" array 4616 is sorted by target offset so we know all the entries for the same 4617 literal will be contiguous. */ 4618 4619 static bfd_boolean 4620 relocations_reach (reloc, remaining_relocs, r_rel) 4621 source_reloc *reloc; 4622 int remaining_relocs; 4623 const r_reloc *r_rel; 4624 { 4625 bfd_vma from_offset, source_address, dest_address; 4626 asection *sec; 4627 int i; 4628 4629 if (!r_reloc_is_defined (r_rel)) 4630 return FALSE; 4631 4632 sec = r_reloc_get_section (r_rel); 4633 from_offset = reloc[0].r_rel.target_offset; 4634 4635 for (i = 0; i < remaining_relocs; i++) 4636 { 4637 if (reloc[i].r_rel.target_offset != from_offset) 4638 break; 4639 4640 /* Ignore relocations that have been removed. */ 4641 if (reloc[i].is_null) 4642 continue; 4643 4644 /* The original and new output section for these must be the same 4645 in order to coalesce. */ 4646 if (r_reloc_get_section (&reloc[i].r_rel)->output_section 4647 != sec->output_section) 4648 return FALSE; 4649 4650 /* A NULL operand means it is not a PC-relative relocation, so 4651 the literal can be moved anywhere. */ 4652 if (reloc[i].opnd) 4653 { 4654 /* Otherwise, check to see that it fits. */ 4655 source_address = (reloc[i].source_sec->output_section->vma 4656 + reloc[i].source_sec->output_offset 4657 + reloc[i].r_rel.rela.r_offset); 4658 dest_address = (sec->output_section->vma 4659 + sec->output_offset 4660 + r_rel->target_offset); 4661 4662 if (!pcrel_reloc_fits (reloc[i].opnd, source_address, dest_address)) 4663 return FALSE; 4664 } 4665 } 4666 4667 return TRUE; 4668 } 4669 4670 4671 /* WARNING: linear search here. If the relocation are in order by 4672 address, we can use a faster binary search. ALSO, we assume that 4673 there is only 1 non-NONE relocation per address. */ 4674 4675 static Elf_Internal_Rela * 4676 get_irel_at_offset (sec, internal_relocs, offset) 4677 asection *sec; 4678 Elf_Internal_Rela *internal_relocs; 4679 bfd_vma offset; 4680 { 4681 unsigned i; 4682 if (!internal_relocs) 4683 return NULL; 4684 for (i = 0; i < sec->reloc_count; i++) 4685 { 4686 Elf_Internal_Rela *irel = &internal_relocs[i]; 4687 if (irel->r_offset == offset 4688 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE) 4689 return irel; 4690 } 4691 return NULL; 4692 } 4693 4694 4695 /* Second relaxation pass. */ 4696 4697 /* Modify all of the relocations to point to the right spot, and if this 4698 is a relaxable section, delete the unwanted literals and fix the 4699 cooked_size. */ 4700 4701 bfd_boolean 4702 relax_section (abfd, sec, link_info) 4703 bfd *abfd; 4704 asection *sec; 4705 struct bfd_link_info *link_info; 4706 { 4707 Elf_Internal_Rela *internal_relocs; 4708 xtensa_relax_info *relax_info; 4709 bfd_byte *contents; 4710 bfd_boolean ok = TRUE; 4711 unsigned i; 4712 4713 relax_info = get_xtensa_relax_info (sec); 4714 BFD_ASSERT (relax_info); 4715 4716 /* Handle property sections (e.g., literal tables) specially. */ 4717 if (xtensa_is_property_section (sec)) 4718 { 4719 BFD_ASSERT (!relax_info->is_relaxable_literal_section); 4720 return relax_property_section (abfd, sec, link_info); 4721 } 4722 4723 internal_relocs = retrieve_internal_relocs (abfd, sec, 4724 link_info->keep_memory); 4725 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 4726 if (contents == NULL && sec->_raw_size != 0) 4727 { 4728 ok = FALSE; 4729 goto error_return; 4730 } 4731 4732 if (internal_relocs) 4733 { 4734 for (i = 0; i < sec->reloc_count; i++) 4735 { 4736 Elf_Internal_Rela *irel; 4737 xtensa_relax_info *target_relax_info; 4738 bfd_vma source_offset; 4739 r_reloc r_rel; 4740 unsigned r_type; 4741 asection *target_sec; 4742 4743 /* Locally change the source address. 4744 Translate the target to the new target address. 4745 If it points to this section and has been removed, 4746 NULLify it. 4747 Write it back. */ 4748 4749 irel = &internal_relocs[i]; 4750 source_offset = irel->r_offset; 4751 4752 r_type = ELF32_R_TYPE (irel->r_info); 4753 r_reloc_init (&r_rel, abfd, irel); 4754 4755 if (relax_info->is_relaxable_literal_section) 4756 { 4757 if (r_type != R_XTENSA_NONE 4758 && find_removed_literal (&relax_info->removed_list, 4759 irel->r_offset)) 4760 { 4761 /* Remove this relocation. */ 4762 if (elf_hash_table (link_info)->dynamic_sections_created) 4763 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel); 4764 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 4765 irel->r_offset = offset_with_removed_literals 4766 (&relax_info->removed_list, irel->r_offset); 4767 continue; 4768 } 4769 source_offset = 4770 offset_with_removed_literals (&relax_info->removed_list, 4771 irel->r_offset); 4772 irel->r_offset = source_offset; 4773 } 4774 4775 target_sec = r_reloc_get_section (&r_rel); 4776 target_relax_info = get_xtensa_relax_info (target_sec); 4777 4778 if (target_relax_info 4779 && target_relax_info->is_relaxable_literal_section) 4780 { 4781 r_reloc new_rel; 4782 reloc_bfd_fix *fix; 4783 4784 translate_reloc (&r_rel, &new_rel); 4785 4786 /* FIXME: If the relocation still references a section in 4787 the same input file, the relocation should be modified 4788 directly instead of adding a "fix" record. */ 4789 4790 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0, 4791 r_reloc_get_section (&new_rel), 4792 new_rel.target_offset); 4793 add_fix (sec, fix); 4794 } 4795 4796 pin_internal_relocs (sec, internal_relocs); 4797 } 4798 } 4799 4800 if (relax_info->is_relaxable_literal_section) 4801 { 4802 /* Walk through the contents and delete literals that are not needed 4803 anymore. */ 4804 4805 unsigned long size = sec->_cooked_size; 4806 unsigned long removed = 0; 4807 4808 removed_literal *reloc = relax_info->removed_list.head; 4809 for (; reloc; reloc = reloc->next) 4810 { 4811 unsigned long upper = sec->_raw_size; 4812 bfd_vma start = reloc->from.target_offset + 4; 4813 if (reloc->next) 4814 upper = reloc->next->from.target_offset; 4815 if (upper - start != 0) 4816 { 4817 BFD_ASSERT (start <= upper); 4818 memmove (contents + start - removed - 4, 4819 contents + start, 4820 upper - start ); 4821 pin_contents (sec, contents); 4822 } 4823 removed += 4; 4824 size -= 4; 4825 } 4826 4827 /* Change the section size. */ 4828 sec->_cooked_size = size; 4829 /* Also shrink _raw_size. (The code in relocate_section that 4830 checks that relocations are within the section must use 4831 _raw_size because of the way the stabs sections are relaxed; 4832 shrinking _raw_size means that these checks will not be 4833 unnecessarily lax.) */ 4834 sec->_raw_size = size; 4835 } 4836 4837 error_return: 4838 release_internal_relocs (sec, internal_relocs); 4839 release_contents (sec, contents); 4840 return ok; 4841 } 4842 4843 4844 /* Fix up a relocation to take account of removed literals. */ 4845 4846 static void 4847 translate_reloc (orig_rel, new_rel) 4848 const r_reloc *orig_rel; 4849 r_reloc *new_rel; 4850 { 4851 asection *sec; 4852 xtensa_relax_info *relax_info; 4853 removed_literal *removed; 4854 unsigned long new_offset; 4855 4856 *new_rel = *orig_rel; 4857 4858 if (!r_reloc_is_defined (orig_rel)) 4859 return; 4860 sec = r_reloc_get_section (orig_rel); 4861 4862 relax_info = get_xtensa_relax_info (sec); 4863 BFD_ASSERT (relax_info); 4864 4865 if (!relax_info->is_relaxable_literal_section) 4866 return; 4867 4868 /* Check if the original relocation is against a literal being removed. */ 4869 removed = find_removed_literal (&relax_info->removed_list, 4870 orig_rel->target_offset); 4871 if (removed) 4872 { 4873 asection *new_sec; 4874 4875 /* The fact that there is still a relocation to this literal indicates 4876 that the literal is being coalesced, not simply removed. */ 4877 BFD_ASSERT (removed->to.abfd != NULL); 4878 4879 /* This was moved to some other address (possibly in another section). */ 4880 *new_rel = removed->to; 4881 new_sec = r_reloc_get_section (new_rel); 4882 if (new_sec != sec) 4883 { 4884 sec = new_sec; 4885 relax_info = get_xtensa_relax_info (sec); 4886 if (!relax_info || !relax_info->is_relaxable_literal_section) 4887 return; 4888 } 4889 } 4890 4891 /* ...and the target address may have been moved within its section. */ 4892 new_offset = offset_with_removed_literals (&relax_info->removed_list, 4893 new_rel->target_offset); 4894 4895 /* Modify the offset and addend. */ 4896 new_rel->target_offset = new_offset; 4897 new_rel->rela.r_addend += (new_offset - new_rel->target_offset); 4898 } 4899 4900 4901 /* For dynamic links, there may be a dynamic relocation for each 4902 literal. The number of dynamic relocations must be computed in 4903 size_dynamic_sections, which occurs before relaxation. When a 4904 literal is removed, this function checks if there is a corresponding 4905 dynamic relocation and shrinks the size of the appropriate dynamic 4906 relocation section accordingly. At this point, the contents of the 4907 dynamic relocation sections have not yet been filled in, so there's 4908 nothing else that needs to be done. */ 4909 4910 static void 4911 shrink_dynamic_reloc_sections (info, abfd, input_section, rel) 4912 struct bfd_link_info *info; 4913 bfd *abfd; 4914 asection *input_section; 4915 Elf_Internal_Rela *rel; 4916 { 4917 Elf_Internal_Shdr *symtab_hdr; 4918 struct elf_link_hash_entry **sym_hashes; 4919 unsigned long r_symndx; 4920 int r_type; 4921 struct elf_link_hash_entry *h; 4922 bfd_boolean dynamic_symbol; 4923 4924 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 4925 sym_hashes = elf_sym_hashes (abfd); 4926 4927 r_type = ELF32_R_TYPE (rel->r_info); 4928 r_symndx = ELF32_R_SYM (rel->r_info); 4929 4930 if (r_symndx < symtab_hdr->sh_info) 4931 h = NULL; 4932 else 4933 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 4934 4935 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info); 4936 4937 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT) 4938 && (input_section->flags & SEC_ALLOC) != 0 4939 && (dynamic_symbol || info->shared)) 4940 { 4941 bfd *dynobj; 4942 const char *srel_name; 4943 asection *srel; 4944 bfd_boolean is_plt = FALSE; 4945 4946 dynobj = elf_hash_table (info)->dynobj; 4947 BFD_ASSERT (dynobj != NULL); 4948 4949 if (dynamic_symbol && r_type == R_XTENSA_PLT) 4950 { 4951 srel_name = ".rela.plt"; 4952 is_plt = TRUE; 4953 } 4954 else 4955 srel_name = ".rela.got"; 4956 4957 /* Reduce size of the .rela.* section by one reloc. */ 4958 srel = bfd_get_section_by_name (dynobj, srel_name); 4959 BFD_ASSERT (srel != NULL); 4960 BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela)); 4961 srel->_cooked_size -= sizeof (Elf32_External_Rela); 4962 4963 /* Also shrink _raw_size. (This seems wrong but other bfd code seems 4964 to assume that linker-created sections will never be relaxed and 4965 hence _raw_size must always equal _cooked_size.) */ 4966 srel->_raw_size = srel->_cooked_size; 4967 4968 if (is_plt) 4969 { 4970 asection *splt, *sgotplt, *srelgot; 4971 int reloc_index, chunk; 4972 4973 /* Find the PLT reloc index of the entry being removed. This 4974 is computed from the size of ".rela.plt". It is needed to 4975 figure out which PLT chunk to resize. Usually "last index 4976 = size - 1" since the index starts at zero, but in this 4977 context, the size has just been decremented so there's no 4978 need to subtract one. */ 4979 reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela); 4980 4981 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK; 4982 splt = elf_xtensa_get_plt_section (dynobj, chunk); 4983 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk); 4984 BFD_ASSERT (splt != NULL && sgotplt != NULL); 4985 4986 /* Check if an entire PLT chunk has just been eliminated. */ 4987 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0) 4988 { 4989 /* The two magic GOT entries for that chunk can go away. */ 4990 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 4991 BFD_ASSERT (srelgot != NULL); 4992 srelgot->reloc_count -= 2; 4993 srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela); 4994 /* Shrink _raw_size (see comment above). */ 4995 srelgot->_raw_size = srelgot->_cooked_size; 4996 4997 sgotplt->_cooked_size -= 8; 4998 4999 /* There should be only one entry left (and it will be 5000 removed below). */ 5001 BFD_ASSERT (sgotplt->_cooked_size == 4); 5002 BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE); 5003 } 5004 5005 BFD_ASSERT (sgotplt->_cooked_size >= 4); 5006 BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE); 5007 5008 sgotplt->_cooked_size -= 4; 5009 splt->_cooked_size -= PLT_ENTRY_SIZE; 5010 5011 /* Shrink _raw_sizes (see comment above). */ 5012 sgotplt->_raw_size = sgotplt->_cooked_size; 5013 splt->_raw_size = splt->_cooked_size; 5014 } 5015 } 5016 } 5017 5018 5019 /* This is similar to relax_section except that when a target is moved, 5020 we shift addresses up. We also need to modify the size. This 5021 algorithm does NOT allow for relocations into the middle of the 5022 property sections. */ 5023 5024 static bfd_boolean 5025 relax_property_section (abfd, sec, link_info) 5026 bfd *abfd; 5027 asection *sec; 5028 struct bfd_link_info *link_info; 5029 { 5030 Elf_Internal_Rela *internal_relocs; 5031 bfd_byte *contents; 5032 unsigned i, nexti; 5033 bfd_boolean ok = TRUE; 5034 5035 internal_relocs = retrieve_internal_relocs (abfd, sec, 5036 link_info->keep_memory); 5037 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 5038 if (contents == NULL && sec->_raw_size != 0) 5039 { 5040 ok = FALSE; 5041 goto error_return; 5042 } 5043 5044 if (internal_relocs) 5045 { 5046 for (i = 0; i < sec->reloc_count; i++) 5047 { 5048 Elf_Internal_Rela *irel; 5049 xtensa_relax_info *target_relax_info; 5050 r_reloc r_rel; 5051 unsigned r_type; 5052 asection *target_sec; 5053 5054 /* Locally change the source address. 5055 Translate the target to the new target address. 5056 If it points to this section and has been removed, MOVE IT. 5057 Also, don't forget to modify the associated SIZE at 5058 (offset + 4). */ 5059 5060 irel = &internal_relocs[i]; 5061 r_type = ELF32_R_TYPE (irel->r_info); 5062 if (r_type == R_XTENSA_NONE) 5063 continue; 5064 5065 r_reloc_init (&r_rel, abfd, irel); 5066 5067 target_sec = r_reloc_get_section (&r_rel); 5068 target_relax_info = get_xtensa_relax_info (target_sec); 5069 5070 if (target_relax_info 5071 && target_relax_info->is_relaxable_literal_section) 5072 { 5073 /* Translate the relocation's destination. */ 5074 bfd_vma new_offset; 5075 bfd_vma new_end_offset; 5076 bfd_byte *size_p; 5077 long old_size, new_size; 5078 5079 new_offset = 5080 offset_with_removed_literals (&target_relax_info->removed_list, 5081 r_rel.target_offset); 5082 5083 /* Assert that we are not out of bounds. */ 5084 size_p = &contents[irel->r_offset + 4]; 5085 old_size = bfd_get_32 (abfd, &contents[irel->r_offset + 4]); 5086 5087 new_end_offset = 5088 offset_with_removed_literals (&target_relax_info->removed_list, 5089 r_rel.target_offset + old_size); 5090 5091 new_size = new_end_offset - new_offset; 5092 if (new_size != old_size) 5093 { 5094 bfd_put_32 (abfd, new_size, size_p); 5095 pin_contents (sec, contents); 5096 } 5097 5098 if (new_offset != r_rel.target_offset) 5099 { 5100 bfd_vma diff = new_offset - r_rel.target_offset; 5101 irel->r_addend += diff; 5102 pin_internal_relocs (sec, internal_relocs); 5103 } 5104 } 5105 } 5106 } 5107 5108 /* Combine adjacent property table entries. This is also done in 5109 finish_dynamic_sections() but at that point it's too late to 5110 reclaim the space in the output section, so we do this twice. */ 5111 5112 if (internal_relocs) 5113 { 5114 Elf_Internal_Rela *last_irel = NULL; 5115 int removed_bytes = 0; 5116 bfd_vma offset, last_irel_offset; 5117 bfd_vma section_size; 5118 5119 /* Walk over memory and irels at the same time. 5120 This REQUIRES that the internal_relocs be sorted by offset. */ 5121 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela), 5122 internal_reloc_compare); 5123 nexti = 0; /* Index into internal_relocs. */ 5124 5125 pin_internal_relocs (sec, internal_relocs); 5126 pin_contents (sec, contents); 5127 5128 last_irel_offset = (bfd_vma) -1; 5129 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size); 5130 BFD_ASSERT (section_size % 8 == 0); 5131 5132 for (offset = 0; offset < section_size; offset += 8) 5133 { 5134 Elf_Internal_Rela *irel, *next_irel; 5135 bfd_vma bytes_to_remove, size, actual_offset; 5136 bfd_boolean remove_this_irel; 5137 5138 irel = NULL; 5139 next_irel = NULL; 5140 5141 /* Find the next two relocations (if there are that many left), 5142 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is 5143 the starting reloc index. After these two loops, "i" 5144 is the index of the first non-NONE reloc past that starting 5145 index, and "nexti" is the index for the next non-NONE reloc 5146 after "i". */ 5147 5148 for (i = nexti; i < sec->reloc_count; i++) 5149 { 5150 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE) 5151 { 5152 irel = &internal_relocs[i]; 5153 break; 5154 } 5155 internal_relocs[i].r_offset -= removed_bytes; 5156 } 5157 5158 for (nexti = i + 1; nexti < sec->reloc_count; nexti++) 5159 { 5160 if (ELF32_R_TYPE (internal_relocs[nexti].r_info) 5161 != R_XTENSA_NONE) 5162 { 5163 next_irel = &internal_relocs[nexti]; 5164 break; 5165 } 5166 internal_relocs[nexti].r_offset -= removed_bytes; 5167 } 5168 5169 remove_this_irel = FALSE; 5170 bytes_to_remove = 0; 5171 actual_offset = offset - removed_bytes; 5172 size = bfd_get_32 (abfd, &contents[actual_offset + 4]); 5173 5174 /* Check that the irels are sorted by offset, 5175 with only one per address. */ 5176 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset); 5177 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset); 5178 5179 /* Make sure there isn't a reloc on the size field. */ 5180 if (irel && irel->r_offset == offset + 4) 5181 { 5182 irel->r_offset -= removed_bytes; 5183 last_irel_offset = irel->r_offset; 5184 } 5185 else if (next_irel && next_irel->r_offset == offset + 4) 5186 { 5187 nexti += 1; 5188 irel->r_offset -= removed_bytes; 5189 next_irel->r_offset -= removed_bytes; 5190 last_irel_offset = next_irel->r_offset; 5191 } 5192 else if (size == 0) 5193 { 5194 /* Always remove entries with zero size. */ 5195 bytes_to_remove = 8; 5196 if (irel && irel->r_offset == offset) 5197 { 5198 remove_this_irel = TRUE; 5199 5200 irel->r_offset -= removed_bytes; 5201 last_irel_offset = irel->r_offset; 5202 } 5203 } 5204 else if (irel && irel->r_offset == offset) 5205 { 5206 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32) 5207 { 5208 if (last_irel) 5209 { 5210 bfd_vma old_size = 5211 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]); 5212 bfd_vma old_address = 5213 (last_irel->r_addend 5214 + bfd_get_32 (abfd, &contents[last_irel->r_offset])); 5215 bfd_vma new_address = 5216 (irel->r_addend 5217 + bfd_get_32 (abfd, &contents[actual_offset])); 5218 5219 if ((ELF32_R_SYM (irel->r_info) == 5220 ELF32_R_SYM (last_irel->r_info)) 5221 && (old_address + old_size == new_address)) 5222 { 5223 /* fix the old size */ 5224 bfd_put_32 (abfd, old_size + size, 5225 &contents[last_irel->r_offset + 4]); 5226 bytes_to_remove = 8; 5227 remove_this_irel = TRUE; 5228 } 5229 else 5230 last_irel = irel; 5231 } 5232 else 5233 last_irel = irel; 5234 } 5235 5236 irel->r_offset -= removed_bytes; 5237 last_irel_offset = irel->r_offset; 5238 } 5239 5240 if (remove_this_irel) 5241 { 5242 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); 5243 irel->r_offset -= bytes_to_remove; 5244 } 5245 5246 if (bytes_to_remove != 0) 5247 { 5248 removed_bytes += bytes_to_remove; 5249 if (offset + 8 < section_size) 5250 memmove (&contents[actual_offset], 5251 &contents[actual_offset+8], 5252 section_size - offset - 8); 5253 } 5254 } 5255 5256 if (removed_bytes) 5257 { 5258 /* Clear the removed bytes. */ 5259 memset (&contents[section_size - removed_bytes], 0, removed_bytes); 5260 5261 sec->_cooked_size = section_size - removed_bytes; 5262 /* Also shrink _raw_size. (The code in relocate_section that 5263 checks that relocations are within the section must use 5264 _raw_size because of the way the stabs sections are 5265 relaxed; shrinking _raw_size means that these checks will 5266 not be unnecessarily lax.) */ 5267 sec->_raw_size = sec->_cooked_size; 5268 5269 if (xtensa_is_littable_section (sec)) 5270 { 5271 bfd *dynobj = elf_hash_table (link_info)->dynobj; 5272 if (dynobj) 5273 { 5274 asection *sgotloc = 5275 bfd_get_section_by_name (dynobj, ".got.loc"); 5276 if (sgotloc) 5277 { 5278 bfd_size_type sgotloc_size = 5279 (sgotloc->_cooked_size ? sgotloc->_cooked_size 5280 : sgotloc->_raw_size); 5281 sgotloc->_cooked_size = sgotloc_size - removed_bytes; 5282 sgotloc->_raw_size = sgotloc_size - removed_bytes; 5283 } 5284 } 5285 } 5286 } 5287 } 5288 5289 error_return: 5290 release_internal_relocs (sec, internal_relocs); 5291 release_contents (sec, contents); 5292 return ok; 5293 } 5294 5295 5296 /* Third relaxation pass. */ 5297 5298 /* Change symbol values to account for removed literals. */ 5299 5300 bfd_boolean 5301 relax_section_symbols (abfd, sec) 5302 bfd *abfd; 5303 asection *sec; 5304 { 5305 xtensa_relax_info *relax_info; 5306 unsigned int sec_shndx; 5307 Elf_Internal_Shdr *symtab_hdr; 5308 Elf_Internal_Sym *isymbuf; 5309 unsigned i, num_syms, num_locals; 5310 5311 relax_info = get_xtensa_relax_info (sec); 5312 BFD_ASSERT (relax_info); 5313 5314 if (!relax_info->is_relaxable_literal_section) 5315 return TRUE; 5316 5317 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 5318 5319 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5320 isymbuf = retrieve_local_syms (abfd); 5321 5322 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 5323 num_locals = symtab_hdr->sh_info; 5324 5325 /* Adjust the local symbols defined in this section. */ 5326 for (i = 0; i < num_locals; i++) 5327 { 5328 Elf_Internal_Sym *isym = &isymbuf[i]; 5329 5330 if (isym->st_shndx == sec_shndx) 5331 { 5332 bfd_vma new_address = offset_with_removed_literals 5333 (&relax_info->removed_list, isym->st_value); 5334 if (new_address != isym->st_value) 5335 isym->st_value = new_address; 5336 } 5337 } 5338 5339 /* Now adjust the global symbols defined in this section. */ 5340 for (i = 0; i < (num_syms - num_locals); i++) 5341 { 5342 struct elf_link_hash_entry *sym_hash; 5343 5344 sym_hash = elf_sym_hashes (abfd)[i]; 5345 5346 if (sym_hash->root.type == bfd_link_hash_warning) 5347 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link; 5348 5349 if ((sym_hash->root.type == bfd_link_hash_defined 5350 || sym_hash->root.type == bfd_link_hash_defweak) 5351 && sym_hash->root.u.def.section == sec) 5352 { 5353 bfd_vma new_address = offset_with_removed_literals 5354 (&relax_info->removed_list, sym_hash->root.u.def.value); 5355 if (new_address != sym_hash->root.u.def.value) 5356 sym_hash->root.u.def.value = new_address; 5357 } 5358 } 5359 5360 return TRUE; 5361 } 5362 5363 5364 /* "Fix" handling functions, called while performing relocations. */ 5365 5366 static void 5367 do_fix_for_relocatable_link (rel, input_bfd, input_section) 5368 Elf_Internal_Rela *rel; 5369 bfd *input_bfd; 5370 asection *input_section; 5371 { 5372 r_reloc r_rel; 5373 asection *sec, *old_sec; 5374 bfd_vma old_offset; 5375 int r_type = ELF32_R_TYPE (rel->r_info); 5376 reloc_bfd_fix *fix_list; 5377 reloc_bfd_fix *fix; 5378 5379 if (r_type == R_XTENSA_NONE) 5380 return; 5381 5382 fix_list = (get_xtensa_relax_info (input_section))->fix_list; 5383 if (fix_list == NULL) 5384 return; 5385 5386 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type); 5387 if (fix == NULL) 5388 return; 5389 5390 r_reloc_init (&r_rel, input_bfd, rel); 5391 old_sec = r_reloc_get_section (&r_rel); 5392 old_offset = r_reloc_get_target_offset (&r_rel); 5393 5394 if (old_sec == NULL || !r_reloc_is_defined (&r_rel)) 5395 { 5396 BFD_ASSERT (r_type == R_XTENSA_ASM_EXPAND); 5397 /* Leave it be. Resolution will happen in a later stage. */ 5398 } 5399 else 5400 { 5401 sec = fix->target_sec; 5402 rel->r_addend += ((sec->output_offset + fix->target_offset) 5403 - (old_sec->output_offset + old_offset)); 5404 } 5405 } 5406 5407 5408 static void 5409 do_fix_for_final_link (rel, input_section, relocationp) 5410 Elf_Internal_Rela *rel; 5411 asection *input_section; 5412 bfd_vma *relocationp; 5413 { 5414 asection *sec; 5415 int r_type = ELF32_R_TYPE (rel->r_info); 5416 reloc_bfd_fix *fix_list; 5417 reloc_bfd_fix *fix; 5418 5419 if (r_type == R_XTENSA_NONE) 5420 return; 5421 5422 fix_list = (get_xtensa_relax_info (input_section))->fix_list; 5423 if (fix_list == NULL) 5424 return; 5425 5426 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type); 5427 if (fix == NULL) 5428 return; 5429 5430 sec = fix->target_sec; 5431 *relocationp = (sec->output_section->vma 5432 + sec->output_offset 5433 + fix->target_offset - rel->r_addend); 5434 } 5435 5436 5437 /* Miscellaneous utility functions.... */ 5438 5439 static asection * 5440 elf_xtensa_get_plt_section (dynobj, chunk) 5441 bfd *dynobj; 5442 int chunk; 5443 { 5444 char plt_name[10]; 5445 5446 if (chunk == 0) 5447 return bfd_get_section_by_name (dynobj, ".plt"); 5448 5449 sprintf (plt_name, ".plt.%u", chunk); 5450 return bfd_get_section_by_name (dynobj, plt_name); 5451 } 5452 5453 5454 static asection * 5455 elf_xtensa_get_gotplt_section (dynobj, chunk) 5456 bfd *dynobj; 5457 int chunk; 5458 { 5459 char got_name[14]; 5460 5461 if (chunk == 0) 5462 return bfd_get_section_by_name (dynobj, ".got.plt"); 5463 5464 sprintf (got_name, ".got.plt.%u", chunk); 5465 return bfd_get_section_by_name (dynobj, got_name); 5466 } 5467 5468 5469 /* Get the input section for a given symbol index. 5470 If the symbol is: 5471 . a section symbol, return the section; 5472 . a common symbol, return the common section; 5473 . an undefined symbol, return the undefined section; 5474 . an indirect symbol, follow the links; 5475 . an absolute value, return the absolute section. */ 5476 5477 static asection * 5478 get_elf_r_symndx_section (abfd, r_symndx) 5479 bfd *abfd; 5480 unsigned long r_symndx; 5481 { 5482 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5483 asection *target_sec = NULL; 5484 if (r_symndx < symtab_hdr->sh_info) 5485 { 5486 Elf_Internal_Sym *isymbuf; 5487 unsigned int section_index; 5488 5489 isymbuf = retrieve_local_syms (abfd); 5490 section_index = isymbuf[r_symndx].st_shndx; 5491 5492 if (section_index == SHN_UNDEF) 5493 target_sec = bfd_und_section_ptr; 5494 else if (section_index > 0 && section_index < SHN_LORESERVE) 5495 target_sec = bfd_section_from_elf_index (abfd, section_index); 5496 else if (section_index == SHN_ABS) 5497 target_sec = bfd_abs_section_ptr; 5498 else if (section_index == SHN_COMMON) 5499 target_sec = bfd_com_section_ptr; 5500 else 5501 /* Who knows? */ 5502 target_sec = NULL; 5503 } 5504 else 5505 { 5506 unsigned long indx = r_symndx - symtab_hdr->sh_info; 5507 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx]; 5508 5509 while (h->root.type == bfd_link_hash_indirect 5510 || h->root.type == bfd_link_hash_warning) 5511 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5512 5513 switch (h->root.type) 5514 { 5515 case bfd_link_hash_defined: 5516 case bfd_link_hash_defweak: 5517 target_sec = h->root.u.def.section; 5518 break; 5519 case bfd_link_hash_common: 5520 target_sec = bfd_com_section_ptr; 5521 break; 5522 case bfd_link_hash_undefined: 5523 case bfd_link_hash_undefweak: 5524 target_sec = bfd_und_section_ptr; 5525 break; 5526 default: /* New indirect warning. */ 5527 target_sec = bfd_und_section_ptr; 5528 break; 5529 } 5530 } 5531 return target_sec; 5532 } 5533 5534 5535 static struct elf_link_hash_entry * 5536 get_elf_r_symndx_hash_entry (abfd, r_symndx) 5537 bfd *abfd; 5538 unsigned long r_symndx; 5539 { 5540 unsigned long indx; 5541 struct elf_link_hash_entry *h; 5542 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5543 5544 if (r_symndx < symtab_hdr->sh_info) 5545 return NULL; 5546 5547 indx = r_symndx - symtab_hdr->sh_info; 5548 h = elf_sym_hashes (abfd)[indx]; 5549 while (h->root.type == bfd_link_hash_indirect 5550 || h->root.type == bfd_link_hash_warning) 5551 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5552 return h; 5553 } 5554 5555 5556 /* Get the section-relative offset for a symbol number. */ 5557 5558 static bfd_vma 5559 get_elf_r_symndx_offset (abfd, r_symndx) 5560 bfd *abfd; 5561 unsigned long r_symndx; 5562 { 5563 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5564 bfd_vma offset = 0; 5565 5566 if (r_symndx < symtab_hdr->sh_info) 5567 { 5568 Elf_Internal_Sym *isymbuf; 5569 isymbuf = retrieve_local_syms (abfd); 5570 offset = isymbuf[r_symndx].st_value; 5571 } 5572 else 5573 { 5574 unsigned long indx = r_symndx - symtab_hdr->sh_info; 5575 struct elf_link_hash_entry *h = 5576 elf_sym_hashes (abfd)[indx]; 5577 5578 while (h->root.type == bfd_link_hash_indirect 5579 || h->root.type == bfd_link_hash_warning) 5580 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5581 if (h->root.type == bfd_link_hash_defined 5582 || h->root.type == bfd_link_hash_defweak) 5583 offset = h->root.u.def.value; 5584 } 5585 return offset; 5586 } 5587 5588 5589 static bfd_boolean 5590 pcrel_reloc_fits (opnd, self_address, dest_address) 5591 xtensa_operand opnd; 5592 bfd_vma self_address; 5593 bfd_vma dest_address; 5594 { 5595 uint32 new_address = 5596 xtensa_operand_do_reloc (opnd, dest_address, self_address); 5597 return (xtensa_operand_encode (opnd, &new_address) 5598 == xtensa_encode_result_ok); 5599 } 5600 5601 5602 static int linkonce_len = sizeof (".gnu.linkonce.") - 1; 5603 static int insn_sec_len = sizeof (XTENSA_INSN_SEC_NAME) - 1; 5604 static int lit_sec_len = sizeof (XTENSA_LIT_SEC_NAME) - 1; 5605 5606 5607 static bfd_boolean 5608 xtensa_is_property_section (sec) 5609 asection *sec; 5610 { 5611 if (strncmp (XTENSA_INSN_SEC_NAME, sec->name, insn_sec_len) == 0 5612 || strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0) 5613 return TRUE; 5614 5615 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0 5616 && (sec->name[linkonce_len] == 'x' 5617 || sec->name[linkonce_len] == 'p') 5618 && sec->name[linkonce_len + 1] == '.') 5619 return TRUE; 5620 5621 return FALSE; 5622 } 5623 5624 5625 static bfd_boolean 5626 xtensa_is_littable_section (sec) 5627 asection *sec; 5628 { 5629 if (strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0) 5630 return TRUE; 5631 5632 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0 5633 && sec->name[linkonce_len] == 'p' 5634 && sec->name[linkonce_len + 1] == '.') 5635 return TRUE; 5636 5637 return FALSE; 5638 } 5639 5640 5641 static bfd_boolean 5642 is_literal_section (sec) 5643 asection *sec; 5644 { 5645 /* FIXME: the current definition of this leaves a lot to be desired.... */ 5646 if (sec == NULL || sec->name == NULL) 5647 return FALSE; 5648 return (strstr (sec->name, "literal") != NULL); 5649 } 5650 5651 5652 static int 5653 internal_reloc_compare (ap, bp) 5654 const PTR ap; 5655 const PTR bp; 5656 { 5657 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap; 5658 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp; 5659 5660 return (a->r_offset - b->r_offset); 5661 } 5662 5663 5664 char * 5665 xtensa_get_property_section_name (sec, base_name) 5666 asection *sec; 5667 const char *base_name; 5668 { 5669 if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0) 5670 { 5671 char *prop_sec_name; 5672 const char *suffix; 5673 char linkonce_kind = 0; 5674 5675 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0) 5676 linkonce_kind = 'x'; 5677 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0) 5678 linkonce_kind = 'p'; 5679 else 5680 abort (); 5681 5682 prop_sec_name = (char *) bfd_malloc (strlen (sec->name) + 1); 5683 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len); 5684 prop_sec_name[linkonce_len] = linkonce_kind; 5685 prop_sec_name[linkonce_len + 1] = '.'; 5686 5687 suffix = sec->name + linkonce_len; 5688 while (*suffix) 5689 { 5690 suffix += 1; 5691 if (suffix[-1] == '.') 5692 break; 5693 } 5694 strcpy (prop_sec_name + linkonce_len + 2, suffix); 5695 5696 return prop_sec_name; 5697 } 5698 5699 return strdup (base_name); 5700 } 5701 5702 5703 /* Other functions called directly by the linker. */ 5704 5705 bfd_boolean 5706 xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure) 5707 bfd *abfd; 5708 asection *sec; 5709 struct bfd_link_info *link_info; 5710 deps_callback_t callback; 5711 PTR closure; 5712 { 5713 Elf_Internal_Rela *internal_relocs; 5714 bfd_byte *contents; 5715 unsigned i; 5716 bfd_boolean ok = TRUE; 5717 5718 /* ".plt*" sections have no explicit relocations but they contain L32R 5719 instructions that reference the corresponding ".got.plt*" sections. */ 5720 if ((sec->flags & SEC_LINKER_CREATED) != 0 5721 && strncmp (sec->name, ".plt", 4) == 0) 5722 { 5723 asection *sgotplt; 5724 5725 /* Find the corresponding ".got.plt*" section. */ 5726 if (sec->name[4] == '\0') 5727 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt"); 5728 else 5729 { 5730 char got_name[14]; 5731 int chunk = 0; 5732 5733 BFD_ASSERT (sec->name[4] == '.'); 5734 chunk = strtol (&sec->name[5], NULL, 10); 5735 5736 sprintf (got_name, ".got.plt.%u", chunk); 5737 sgotplt = bfd_get_section_by_name (sec->owner, got_name); 5738 } 5739 BFD_ASSERT (sgotplt); 5740 5741 /* Assume worst-case offsets: L32R at the very end of the ".plt" 5742 section referencing a literal at the very beginning of 5743 ".got.plt". This is very close to the real dependence, anyway. */ 5744 (*callback) (sec, sec->_raw_size, sgotplt, 0, closure); 5745 } 5746 5747 internal_relocs = retrieve_internal_relocs (abfd, sec, 5748 link_info->keep_memory); 5749 if (internal_relocs == NULL 5750 || sec->reloc_count == 0) 5751 return ok; 5752 5753 /* Cache the contents for the duration of this scan. */ 5754 contents = retrieve_contents (abfd, sec, link_info->keep_memory); 5755 if (contents == NULL && sec->_raw_size != 0) 5756 { 5757 ok = FALSE; 5758 goto error_return; 5759 } 5760 5761 if (xtensa_default_isa == NULL) 5762 xtensa_isa_init (); 5763 5764 for (i = 0; i < sec->reloc_count; i++) 5765 { 5766 Elf_Internal_Rela *irel = &internal_relocs[i]; 5767 if (is_l32r_relocation (sec, contents, irel)) 5768 { 5769 r_reloc l32r_rel; 5770 asection *target_sec; 5771 bfd_vma target_offset; 5772 5773 r_reloc_init (&l32r_rel, abfd, irel); 5774 target_sec = NULL; 5775 target_offset = 0; 5776 /* L32Rs must be local to the input file. */ 5777 if (r_reloc_is_defined (&l32r_rel)) 5778 { 5779 target_sec = r_reloc_get_section (&l32r_rel); 5780 target_offset = r_reloc_get_target_offset (&l32r_rel); 5781 } 5782 (*callback) (sec, irel->r_offset, target_sec, target_offset, 5783 closure); 5784 } 5785 } 5786 5787 error_return: 5788 release_internal_relocs (sec, internal_relocs); 5789 release_contents (sec, contents); 5790 return ok; 5791 } 5792 5793 /* The default literal sections should always be marked as "code" (i.e., 5794 SHF_EXECINSTR). This is particularly important for the Linux kernel 5795 module loader so that the literals are not placed after the text. */ 5796 static struct bfd_elf_special_section const elf_xtensa_special_sections[]= 5797 { 5798 { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 5799 { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 5800 { ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 5801 { NULL, 0, 0, 0, 0 } 5802 }; 5803 5804 5805 #ifndef ELF_ARCH 5806 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec 5807 #define TARGET_LITTLE_NAME "elf32-xtensa-le" 5808 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec 5809 #define TARGET_BIG_NAME "elf32-xtensa-be" 5810 #define ELF_ARCH bfd_arch_xtensa 5811 5812 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040 5813 release. However, we still have to generate files with the EM_XTENSA_OLD 5814 value so that pre-T1040 tools can read the files. As soon as we stop 5815 caring about pre-T1040 tools, the following two values should be 5816 swapped. At the same time, any other code that uses EM_XTENSA_OLD 5817 (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA. */ 5818 #define ELF_MACHINE_CODE EM_XTENSA_OLD 5819 #define ELF_MACHINE_ALT1 EM_XTENSA 5820 5821 #if XCHAL_HAVE_MMU 5822 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE) 5823 #else /* !XCHAL_HAVE_MMU */ 5824 #define ELF_MAXPAGESIZE 1 5825 #endif /* !XCHAL_HAVE_MMU */ 5826 #endif /* ELF_ARCH */ 5827 5828 #define elf_backend_can_gc_sections 1 5829 #define elf_backend_can_refcount 1 5830 #define elf_backend_plt_readonly 1 5831 #define elf_backend_got_header_size 4 5832 #define elf_backend_want_dynbss 0 5833 #define elf_backend_want_got_plt 1 5834 5835 #define elf_info_to_howto elf_xtensa_info_to_howto_rela 5836 5837 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data 5838 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook 5839 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data 5840 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section 5841 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup 5842 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags 5843 5844 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol 5845 #define elf_backend_check_relocs elf_xtensa_check_relocs 5846 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections 5847 #define elf_backend_discard_info elf_xtensa_discard_info 5848 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs 5849 #define elf_backend_final_write_processing elf_xtensa_final_write_processing 5850 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections 5851 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol 5852 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook 5853 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook 5854 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus 5855 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo 5856 #define elf_backend_hide_symbol elf_xtensa_hide_symbol 5857 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map 5858 #define elf_backend_object_p elf_xtensa_object_p 5859 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class 5860 #define elf_backend_relocate_section elf_xtensa_relocate_section 5861 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections 5862 #define elf_backend_special_sections elf_xtensa_special_sections 5863 5864 #include "elf32-target.h" 5865