1 /* SPARC-specific support for 32-bit ELF
2 Copyright 1993 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 static CONST
struct reloc_howto_struct
*bfd_elf32_bfd_reloc_type_lookup
27 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
28 static void elf_info_to_howto
29 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
30 static boolean elf32_sparc_create_dynamic_sections
31 PARAMS ((bfd
*, struct bfd_link_info
*));
32 static boolean elf32_sparc_adjust_dynamic_symbol
33 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
34 static boolean elf32_sparc_allocate_dynamic_section
35 PARAMS ((bfd
*, const char *));
36 static boolean elf32_sparc_size_dynamic_sections
37 PARAMS ((bfd
*, struct bfd_link_info
*));
38 static boolean elf32_sparc_relocate_section
39 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
40 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**, char *));
41 static boolean elf32_sparc_finish_dynamic_symbol
42 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
44 static boolean elf32_sparc_finish_dynamic_sections
45 PARAMS ((bfd
*, struct bfd_link_info
*));
50 R_SPARC_8
, R_SPARC_16
, R_SPARC_32
,
51 R_SPARC_DISP8
, R_SPARC_DISP16
, R_SPARC_DISP32
,
52 R_SPARC_WDISP30
, R_SPARC_WDISP22
,
53 R_SPARC_HI22
, R_SPARC_22
,
54 R_SPARC_13
, R_SPARC_LO10
,
55 R_SPARC_GOT10
, R_SPARC_GOT13
, R_SPARC_GOT22
,
56 R_SPARC_PC10
, R_SPARC_PC22
,
59 R_SPARC_GLOB_DAT
, R_SPARC_JMP_SLOT
,
66 static CONST
char *CONST reloc_type_names
[] =
69 "R_SPARC_8", "R_SPARC_16", "R_SPARC_32",
70 "R_SPARC_DISP8", "R_SPARC_DISP16", "R_SPARC_DISP32",
71 "R_SPARC_WDISP30", "R_SPARC_WDISP22",
72 "R_SPARC_HI22", "R_SPARC_22",
73 "R_SPARC_13", "R_SPARC_LO10",
74 "R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22",
75 "R_SPARC_PC10", "R_SPARC_PC22",
78 "R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT",
84 static reloc_howto_type elf_sparc_howto_table
[] =
86 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_NONE", false,0,0x00000000,true),
87 HOWTO(R_SPARC_8
, 0,0, 8,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_8", false,0,0x000000ff,true),
88 HOWTO(R_SPARC_16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_16", false,0,0x0000ffff,true),
89 HOWTO(R_SPARC_32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_32", false,0,0xffffffff,true),
90 HOWTO(R_SPARC_DISP8
, 0,0, 8,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
,"R_SPARC_DISP8", false,0,0x000000ff,true),
91 HOWTO(R_SPARC_DISP16
, 0,1,16,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
,"R_SPARC_DISP16", false,0,0x0000ffff,true),
92 HOWTO(R_SPARC_DISP32
, 0,2,32,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
,"R_SPARC_DISP32", false,0,0x00ffffff,true),
93 HOWTO(R_SPARC_WDISP30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
,"R_SPARC_WDISP30", false,0,0x3fffffff,true),
94 HOWTO(R_SPARC_WDISP22
, 2,2,22,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
,"R_SPARC_WDISP22", false,0,0x003fffff,true),
95 HOWTO(R_SPARC_HI22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_HI22", false,0,0x003fffff,true),
96 HOWTO(R_SPARC_22
, 0,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_22", false,0,0x003fffff,true),
97 HOWTO(R_SPARC_13
, 0,2,13,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_13", false,0,0x00001fff,true),
98 HOWTO(R_SPARC_LO10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_LO10", false,0,0x000003ff,true),
99 HOWTO(R_SPARC_GOT10
, 0,2,10,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_GOT10", false,0,0x000003ff,true),
100 HOWTO(R_SPARC_GOT13
, 0,2,13,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_GOT13", false,0,0x00001fff,true),
101 HOWTO(R_SPARC_GOT22
, 10,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_GOT22", false,0,0x003fffff,true),
102 HOWTO(R_SPARC_PC10
, 0,2,10,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_PC10", false,0,0x000003ff,true),
103 HOWTO(R_SPARC_PC22
, 0,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_PC22", false,0,0x003fffff,true),
104 HOWTO(R_SPARC_WPLT30
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_WPLT30", false,0,0x00000000,true),
105 HOWTO(R_SPARC_COPY
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_COPY", false,0,0x00000000,true),
106 HOWTO(R_SPARC_GLOB_DAT
,0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
107 HOWTO(R_SPARC_JMP_SLOT
,0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
108 HOWTO(R_SPARC_RELATIVE
,0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_RELATIVE",false,0,0x00000000,true),
109 HOWTO(R_SPARC_UA32
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
,"R_SPARC_UA32", false,0,0x00000000,true),
112 struct elf_reloc_map
{
113 unsigned char bfd_reloc_val
;
114 unsigned char elf_reloc_val
;
117 static CONST
struct elf_reloc_map sparc_reloc_map
[] =
119 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
120 { BFD_RELOC_16
, R_SPARC_16
, },
121 { BFD_RELOC_8
, R_SPARC_8
},
122 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
123 { BFD_RELOC_CTOR
, R_SPARC_32
}, /* @@ Assumes 32 bits. */
124 { BFD_RELOC_32
, R_SPARC_32
},
125 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
126 { BFD_RELOC_HI22
, R_SPARC_HI22
},
127 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
128 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
129 { BFD_RELOC_SPARC22
, R_SPARC_22
},
130 { BFD_RELOC_SPARC13
, R_SPARC_13
},
131 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
132 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
133 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
134 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
135 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
136 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
137 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
138 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
139 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
140 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
141 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
142 /* { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
145 static CONST
struct reloc_howto_struct
*
146 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
148 bfd_reloc_code_real_type code
;
151 for (i
= 0; i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
153 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
154 return &elf_sparc_howto_table
[(int) sparc_reloc_map
[i
].elf_reloc_val
];
160 elf_info_to_howto (abfd
, cache_ptr
, dst
)
163 Elf_Internal_Rela
*dst
;
165 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_SPARC_max
);
166 cache_ptr
->howto
= &elf_sparc_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
170 /* Functions for the SPARC ELF linker. */
172 /* The name of the dynamic interpreter. This is put in the .interp
175 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
177 /* The nop opcode we use. */
179 #define SPARC_NOP 0x01000000
181 /* The size in bytes of an entry in the procedure linkage table. */
183 #define PLT_ENTRY_SIZE 12
185 /* The first four entries in a procedure linkage table are reserved,
186 and the initial contents are unimportant (we zero them out).
187 Subsequent entries look like this. See the SVR4 ABI SPARC
188 supplement to see how this works. */
190 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
191 #define PLT_ENTRY_WORD0 0x03000000
192 /* b,a .plt0. We fill in the offset later. */
193 #define PLT_ENTRY_WORD1 0x30800000
195 #define PLT_ENTRY_WORD2 SPARC_NOP
197 /* Create dynamic sections when linking against a dynamic object. */
200 elf32_sparc_create_dynamic_sections (abfd
, info
)
202 struct bfd_link_info
*info
;
205 register asection
*s
;
206 struct elf_link_hash_entry
*h
;
208 /* We need to create .plt, .rela.plt, .got, .dynbss, and .rela.bss
211 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
213 s
= bfd_make_section (abfd
, ".plt");
215 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
216 || ! bfd_set_section_alignment (abfd
, s
, 2))
219 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
222 if (! (_bfd_generic_link_add_one_symbol
223 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, (bfd_vma
) 0,
224 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
225 (struct bfd_link_hash_entry
**) &h
)))
227 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
229 /* The first four entries in .plt are reserved. */
230 s
->_raw_size
= 4 * PLT_ENTRY_SIZE
;
232 s
= bfd_make_section (abfd
, ".rela.plt");
234 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
235 || ! bfd_set_section_alignment (abfd
, s
, 2))
238 s
= bfd_make_section (abfd
, ".got");
240 || ! bfd_set_section_flags (abfd
, s
, flags
)
241 || ! bfd_set_section_alignment (abfd
, s
, 2))
244 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
245 section. We don't do this in the linker script because we don't
246 want to define the symbol if we are not creating a global offset
247 table. FIXME: The Solaris linker puts _GLOBAL_OFFSET_TABLE_ at
248 the start of the .got section, but when using the small PIC model
249 the .got is accessed using a signed 13 bit offset. Shouldn't
250 _GLOBAL_OFFSET_TABLE_ be located at .got + 4096? */
252 if (! (_bfd_generic_link_add_one_symbol
253 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
, (bfd_vma
) 0,
254 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
255 (struct bfd_link_hash_entry
**) &h
)))
257 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
259 /* The first global offset table entry is reserved. */
262 /* The .dynbss section is a place to put symbols which are defined
263 by dynamic objects, are referenced by regular objects, and are
264 not functions. We must allocate space for them in the process
265 image and use a R_SPARC_COPY reloc to tell the dynamic linker to
266 initialize them at run time. The linker script puts the .dynbss
267 section into the .bss section of the final image. */
268 s
= bfd_make_section (abfd
, ".dynbss");
270 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
))
273 /* The .rela.bss section holds copy relocs. */
274 s
= bfd_make_section (abfd
, ".rela.bss");
276 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
277 || ! bfd_set_section_alignment (abfd
, s
, 2))
283 /* Adjust a symbol defined by a dynamic object and referenced by a
284 regular object. The current definition is in some section of the
285 dynamic object, but we're not including those sections. We have to
286 change the definition to something the rest of the link can
290 elf32_sparc_adjust_dynamic_symbol (info
, h
)
291 struct bfd_link_info
*info
;
292 struct elf_link_hash_entry
*h
;
296 unsigned int power_of_two
;
298 dynobj
= elf_hash_table (info
)->dynobj
;
300 /* Make sure we know what is going on here. */
301 BFD_ASSERT (dynobj
!= NULL
302 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
303 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
304 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
305 && h
->root
.type
== bfd_link_hash_defined
306 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
307 == bfd_target_elf_flavour
)
308 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
310 && h
->root
.u
.def
.section
->output_section
== NULL
);
312 /* If this is a function, put it in the procedure linkage table. We
313 will fill in the contents of the procedure linkage table later
314 (although we could actually do it here). */
315 if (h
->type
== STT_FUNC
)
317 s
= bfd_get_section_by_name (dynobj
, ".plt");
318 BFD_ASSERT (s
!= NULL
);
320 /* The procedure linkage table has a maximum size. */
321 if (s
->_raw_size
>= 0x400000)
323 bfd_set_error (bfd_error_bad_value
);
327 /* Set the symbol to this location in the .plt. */
328 h
->root
.u
.def
.section
= s
;
329 h
->root
.u
.def
.value
= s
->_raw_size
;
331 /* Make room for this entry. */
332 s
->_raw_size
+= PLT_ENTRY_SIZE
;
334 /* We also need to make an entry in the .rela.plt section. */
336 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
337 BFD_ASSERT (s
!= NULL
);
338 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
343 /* If this is a weak symbol, and there is a real definition, the
344 processor independent code will have arranged for us to see the
345 real definition first, and we can just use the same value. */
346 if (h
->weakdef
!= NULL
)
348 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
);
349 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
350 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
351 h
->copy_offset
= (bfd_vma
) -1;
355 /* This is a reference to a symbol defined by a dynamic object which
356 is not a function. We must allocate it in our .dynbss section,
357 which will become part of the .bss section of the executable.
358 There will be an entry for this symbol in the .dynsym section.
359 The dynamic object will contain position independent code, so all
360 references from the dynamic object to this symbol will go through
361 the global offset table. The dynamic linker will use the .dynsym
362 entry to determine the address it must put in the global offset
363 table, so both the dynamic object and the regular object will
364 refer to the same memory location for the variable. */
366 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
367 BFD_ASSERT (s
!= NULL
);
369 /* If the symbol is currently defined in the .bss section of the
370 dynamic object, then it is OK to simply initialize it to zero.
371 If the symbol is in some other section, we must generate a
372 R_SPARC_COPY reloc to tell the dynamic linker to copy the initial
373 value out of the dynamic object and into the runtime process
374 image. We need to remember the offset into the .rel.bss section
375 we are going to use. */
376 if ((h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0)
377 h
->copy_offset
= (bfd_vma
) -1;
382 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
383 BFD_ASSERT (srel
!= NULL
);
384 h
->copy_offset
= srel
->_raw_size
;
385 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
388 /* We need to figure out the alignment required for this symbol. I
389 have no idea how ELF linkers handle this. */
390 power_of_two
= bfd_log2 (h
->size
);
391 if (power_of_two
> 3)
394 /* Apply the required alignment. */
395 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
396 (bfd_size_type
) (1 << power_of_two
));
397 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
399 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
403 /* Define the symbol as being at this point in the section. */
404 h
->root
.u
.def
.section
= s
;
405 h
->root
.u
.def
.value
= s
->_raw_size
;
407 /* Increment the section size to make room for the symbol. */
408 s
->_raw_size
+= h
->size
;
413 /* Allocate contents for a section. */
415 static INLINE boolean
416 elf32_sparc_allocate_dynamic_section (dynobj
, name
)
420 register asection
*s
;
422 s
= bfd_get_section_by_name (dynobj
, name
);
423 BFD_ASSERT (s
!= NULL
);
424 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
425 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
427 bfd_set_error (bfd_error_no_memory
);
433 /* Set the sizes of the dynamic sections. */
436 elf32_sparc_size_dynamic_sections (output_bfd
, info
)
438 struct bfd_link_info
*info
;
443 dynobj
= elf_hash_table (info
)->dynobj
;
444 BFD_ASSERT (dynobj
!= NULL
);
446 /* Set the contents of the .interp section to the interpreter. */
449 s
= bfd_get_section_by_name (dynobj
, ".interp");
450 BFD_ASSERT (s
!= NULL
);
451 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
452 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
455 /* Make space for the trailing nop in .plt. */
456 s
= bfd_get_section_by_name (dynobj
, ".plt");
457 BFD_ASSERT (s
!= NULL
);
460 /* The adjust_dynamic_symbol entry point has determined the sizes of
461 the various dynamic sections. Allocate some memory for them to
463 if (! elf32_sparc_allocate_dynamic_section (dynobj
, ".plt")
464 || ! elf32_sparc_allocate_dynamic_section (dynobj
, ".rela.plt")
465 || ! elf32_sparc_allocate_dynamic_section (dynobj
, ".got")
466 || ! elf32_sparc_allocate_dynamic_section (dynobj
, ".rela.bss"))
469 /* Add some entries to the .dynamic section. We fill in the values
470 later, in elf32_sparc_finish_dynamic_sections, but we must add
471 the entries now so that we get the correct size for the .dynamic
472 section. The DT_DEBUG entry is filled in by the dynamic linker
473 and used by the debugger. */
474 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0)
475 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
476 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
477 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
478 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0)
479 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELA
, 0)
480 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELASZ
, 0)
481 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELAENT
,
482 sizeof (Elf32_External_Rela
)))
488 /* Relocate a SPARC ELF section. */
491 elf32_sparc_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
492 contents
, relocs
, local_syms
, local_sections
,
495 struct bfd_link_info
*info
;
497 asection
*input_section
;
499 Elf_Internal_Rela
*relocs
;
500 Elf_Internal_Sym
*local_syms
;
501 asection
**local_sections
;
504 Elf_Internal_Shdr
*symtab_hdr
;
505 struct elf_link_hash_entry
**sym_hashes
;
506 Elf_Internal_Rela
*rel
;
507 Elf_Internal_Rela
*relend
;
509 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
510 sym_hashes
= elf_sym_hashes (input_bfd
);
513 relend
= relocs
+ input_section
->reloc_count
;
514 for (; rel
< relend
; rel
++)
517 const reloc_howto_type
*howto
;
519 struct elf_link_hash_entry
*h
;
520 Elf_Internal_Sym
*sym
;
523 bfd_reloc_status_type r
;
525 r_type
= ELF32_R_TYPE (rel
->r_info
);
526 if (r_type
< 0 || r_type
>= (int) R_SPARC_max
)
528 bfd_set_error (bfd_error_bad_value
);
531 howto
= elf_sparc_howto_table
+ r_type
;
533 r_symndx
= ELF32_R_SYM (rel
->r_info
);
535 if (info
->relocateable
)
537 /* This is a relocateable link. We don't have to change
538 anything, unless the reloc is against a section symbol,
539 in which case we have to adjust according to where the
540 section symbol winds up in the output section. */
541 if (r_symndx
< symtab_hdr
->sh_info
)
543 sym
= local_syms
+ r_symndx
;
544 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
546 sec
= local_sections
[r_symndx
];
547 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
554 /* This is a final link. */
558 if (r_symndx
< symtab_hdr
->sh_info
)
560 sym
= local_syms
+ r_symndx
;
561 sec
= local_sections
[r_symndx
];
562 relocation
= (sec
->output_section
->vma
570 indx
= r_symndx
- symtab_hdr
->sh_info
;
571 h
= sym_hashes
[indx
];
572 if (h
->root
.type
== bfd_link_hash_defined
)
574 sec
= h
->root
.u
.def
.section
;
575 relocation
= (h
->root
.u
.def
.value
576 + sec
->output_section
->vma
577 + sec
->output_offset
);
579 else if (h
->root
.type
== bfd_link_hash_weak
)
583 if (! ((*info
->callbacks
->undefined_symbol
)
584 (info
, h
->root
.root
.string
, input_bfd
,
585 input_section
, rel
->r_offset
)))
591 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
592 contents
, rel
->r_offset
,
593 relocation
, rel
->r_addend
);
595 if (r
!= bfd_reloc_ok
)
600 case bfd_reloc_outofrange
:
602 case bfd_reloc_overflow
:
607 name
= h
->root
.root
.string
;
610 name
= output_names
+ sym
->st_name
;
614 name
= bfd_section_name (input_bfd
, sec
);
616 if (! ((*info
->callbacks
->reloc_overflow
)
617 (info
, name
, howto
->name
, (bfd_vma
) 0,
618 input_bfd
, input_section
, rel
->r_offset
)))
629 /* Finish up dynamic symbol handling. We set the contents of various
630 dynamic sections here. */
633 elf32_sparc_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
635 struct bfd_link_info
*info
;
636 struct elf_link_hash_entry
*h
;
637 Elf_Internal_Sym
*sym
;
639 /* If this symbol is not defined by a dynamic object, or is not
640 referenced by a regular object, ignore it. */
641 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
642 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
643 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
645 /* Mark some specially defined symbols as absolute. */
646 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
647 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
648 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
649 sym
->st_shndx
= SHN_ABS
;
653 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
654 BFD_ASSERT (h
->dynindx
!= -1);
656 if (h
->type
== STT_FUNC
)
660 Elf_Internal_Rela rela
;
662 splt
= h
->root
.u
.def
.section
;
663 BFD_ASSERT (strcmp (bfd_get_section_name (splt
->owner
, splt
), ".plt")
665 srela
= bfd_get_section_by_name (splt
->owner
, ".rela.plt");
666 BFD_ASSERT (srela
!= NULL
);
668 /* Fill in the entry in the procedure linkage table. */
669 bfd_put_32 (output_bfd
,
670 PLT_ENTRY_WORD0
+ h
->root
.u
.def
.value
,
671 splt
->contents
+ h
->root
.u
.def
.value
);
672 bfd_put_32 (output_bfd
,
674 + (((- (h
->root
.u
.def
.value
+ 4)) >> 2) & 0x3fffff)),
675 splt
->contents
+ h
->root
.u
.def
.value
+ 4);
676 bfd_put_32 (output_bfd
, PLT_ENTRY_WORD2
,
677 splt
->contents
+ h
->root
.u
.def
.value
+ 8);
679 /* Fill in the entry in the .rela.plt section. */
680 rela
.r_offset
= (splt
->output_section
->vma
681 + splt
->output_offset
682 + h
->root
.u
.def
.value
);
683 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_JMP_SLOT
);
685 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
686 ((Elf32_External_Rela
*) srela
->contents
687 + (h
->root
.u
.def
.value
/ PLT_ENTRY_SIZE
690 /* Mark the symbol as undefined, rather than as defined in the
691 .plt section. Leave the value alone. */
692 sym
->st_shndx
= SHN_UNDEF
;
696 /* This is not a function. We have already allocated memory for
697 it in the .bss section (via .dynbss). All we have to do here
698 is create a COPY reloc if required. */
699 if (h
->copy_offset
!= (bfd_vma
) -1)
702 Elf_Internal_Rela rela
;
704 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
706 BFD_ASSERT (s
!= NULL
);
708 rela
.r_offset
= (h
->root
.u
.def
.value
709 + h
->root
.u
.def
.section
->output_section
->vma
710 + h
->root
.u
.def
.section
->output_offset
);
711 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_COPY
);
713 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
714 ((Elf32_External_Rela
*)
715 (s
->contents
+ h
->copy_offset
)));
722 /* Finish up the dynamic sections. */
725 elf32_sparc_finish_dynamic_sections (output_bfd
, info
)
727 struct bfd_link_info
*info
;
732 Elf32_External_Dyn
*dyncon
, *dynconend
;
734 splt
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
, ".plt");
735 sgot
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
, ".got");
736 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
, ".dynamic");
737 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& sdyn
!= NULL
);
739 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
740 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
741 for (; dyncon
< dynconend
; dyncon
++)
743 Elf_Internal_Dyn dyn
;
747 bfd_elf32_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
, &dyn
);
751 case DT_PLTGOT
: name
= ".plt"; size
= false; break;
752 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= true; break;
753 case DT_JMPREL
: name
= ".rela.plt"; size
= false; break;
754 default: name
= NULL
; size
= false; break;
761 s
= bfd_get_section_by_name (output_bfd
, name
);
762 BFD_ASSERT (s
!= NULL
);
764 dyn
.d_un
.d_ptr
= s
->vma
;
767 if (s
->_cooked_size
!= 0)
768 dyn
.d_un
.d_val
= s
->_cooked_size
;
770 dyn
.d_un
.d_val
= s
->_raw_size
;
772 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
776 /* Clear the first four entries in the procedure linkage table, and
777 put a nop in the last four bytes. */
778 if (splt
->_raw_size
> 0)
780 memset (splt
->contents
, 0, 4 * PLT_ENTRY_SIZE
);
781 bfd_put_32 (output_bfd
, SPARC_NOP
,
782 splt
->contents
+ splt
->_raw_size
- 4);
785 /* Set the first entry in the global offset table to the address of
786 the dynamic section. */
787 if (sgot
->_raw_size
> 0)
788 bfd_put_32 (output_bfd
,
789 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
792 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
793 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
799 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
800 #define TARGET_BIG_NAME "elf32-sparc"
801 #define ELF_ARCH bfd_arch_sparc
802 #define ELF_MACHINE_CODE EM_SPARC
803 #define ELF_MAXPAGESIZE 0x10000
804 #define elf_backend_create_dynamic_sections \
805 elf32_sparc_create_dynamic_sections
806 #define elf_backend_adjust_dynamic_symbol \
807 elf32_sparc_adjust_dynamic_symbol
808 #define elf_backend_size_dynamic_sections \
809 elf32_sparc_size_dynamic_sections
810 #define elf_backend_relocate_section elf32_sparc_relocate_section
811 #define elf_backend_finish_dynamic_symbol \
812 elf32_sparc_finish_dynamic_symbol
813 #define elf_backend_finish_dynamic_sections \
814 elf32_sparc_finish_dynamic_sections
816 #include "elf32-target.h"