Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* ELF linking support for BFD. |
aad5d350 | 2 | Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 |
7898deda | 3 | Free Software Foundation, Inc. |
252b5132 RH |
4 | |
5 | This file is part of BFD, the Binary File Descriptor library. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #include "bfd.h" | |
22 | #include "sysdep.h" | |
23 | #include "bfdlink.h" | |
24 | #include "libbfd.h" | |
25 | #define ARCH_SIZE 0 | |
26 | #include "elf-bfd.h" | |
27 | ||
b34976b6 | 28 | bfd_boolean |
252b5132 RH |
29 | _bfd_elf_create_got_section (abfd, info) |
30 | bfd *abfd; | |
31 | struct bfd_link_info *info; | |
32 | { | |
33 | flagword flags; | |
aad5d350 | 34 | asection *s; |
252b5132 | 35 | struct elf_link_hash_entry *h; |
14a793b2 | 36 | struct bfd_link_hash_entry *bh; |
252b5132 RH |
37 | struct elf_backend_data *bed = get_elf_backend_data (abfd); |
38 | int ptralign; | |
39 | ||
40 | /* This function may be called more than once. */ | |
aad5d350 AM |
41 | s = bfd_get_section_by_name (abfd, ".got"); |
42 | if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0) | |
b34976b6 | 43 | return TRUE; |
252b5132 RH |
44 | |
45 | switch (bed->s->arch_size) | |
46 | { | |
bb0deeff AO |
47 | case 32: |
48 | ptralign = 2; | |
49 | break; | |
50 | ||
51 | case 64: | |
52 | ptralign = 3; | |
53 | break; | |
54 | ||
55 | default: | |
56 | bfd_set_error (bfd_error_bad_value); | |
b34976b6 | 57 | return FALSE; |
252b5132 RH |
58 | } |
59 | ||
60 | flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | |
61 | | SEC_LINKER_CREATED); | |
62 | ||
63 | s = bfd_make_section (abfd, ".got"); | |
64 | if (s == NULL | |
65 | || !bfd_set_section_flags (abfd, s, flags) | |
66 | || !bfd_set_section_alignment (abfd, s, ptralign)) | |
b34976b6 | 67 | return FALSE; |
252b5132 RH |
68 | |
69 | if (bed->want_got_plt) | |
70 | { | |
71 | s = bfd_make_section (abfd, ".got.plt"); | |
72 | if (s == NULL | |
73 | || !bfd_set_section_flags (abfd, s, flags) | |
74 | || !bfd_set_section_alignment (abfd, s, ptralign)) | |
b34976b6 | 75 | return FALSE; |
252b5132 RH |
76 | } |
77 | ||
2517a57f AM |
78 | if (bed->want_got_sym) |
79 | { | |
80 | /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got | |
81 | (or .got.plt) section. We don't do this in the linker script | |
82 | because we don't want to define the symbol if we are not creating | |
83 | a global offset table. */ | |
14a793b2 | 84 | bh = NULL; |
2517a57f AM |
85 | if (!(_bfd_generic_link_add_one_symbol |
86 | (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, | |
b34976b6 | 87 | bed->got_symbol_offset, (const char *) NULL, FALSE, |
14a793b2 | 88 | bed->collect, &bh))) |
b34976b6 | 89 | return FALSE; |
14a793b2 | 90 | h = (struct elf_link_hash_entry *) bh; |
2517a57f AM |
91 | h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; |
92 | h->type = STT_OBJECT; | |
252b5132 | 93 | |
2517a57f AM |
94 | if (info->shared |
95 | && ! _bfd_elf_link_record_dynamic_symbol (info, h)) | |
b34976b6 | 96 | return FALSE; |
252b5132 | 97 | |
2517a57f AM |
98 | elf_hash_table (info)->hgot = h; |
99 | } | |
252b5132 RH |
100 | |
101 | /* The first bit of the global offset table is the header. */ | |
102 | s->_raw_size += bed->got_header_size + bed->got_symbol_offset; | |
103 | ||
b34976b6 | 104 | return TRUE; |
252b5132 RH |
105 | } |
106 | \f | |
252b5132 RH |
107 | /* Create dynamic sections when linking against a dynamic object. */ |
108 | ||
b34976b6 | 109 | bfd_boolean |
252b5132 RH |
110 | _bfd_elf_create_dynamic_sections (abfd, info) |
111 | bfd *abfd; | |
112 | struct bfd_link_info *info; | |
113 | { | |
114 | flagword flags, pltflags; | |
aad5d350 | 115 | asection *s; |
252b5132 | 116 | struct elf_backend_data *bed = get_elf_backend_data (abfd); |
062e2358 | 117 | int ptralign; |
252b5132 RH |
118 | |
119 | switch (bed->s->arch_size) | |
120 | { | |
bb0deeff AO |
121 | case 32: |
122 | ptralign = 2; | |
123 | break; | |
124 | ||
125 | case 64: | |
126 | ptralign = 3; | |
127 | break; | |
128 | ||
129 | default: | |
130 | bfd_set_error (bfd_error_bad_value); | |
b34976b6 | 131 | return FALSE; |
252b5132 RH |
132 | } |
133 | ||
134 | /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and | |
135 | .rel[a].bss sections. */ | |
136 | ||
137 | flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | |
138 | | SEC_LINKER_CREATED); | |
139 | ||
140 | pltflags = flags; | |
141 | pltflags |= SEC_CODE; | |
142 | if (bed->plt_not_loaded) | |
5d1634d7 | 143 | pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); |
252b5132 RH |
144 | if (bed->plt_readonly) |
145 | pltflags |= SEC_READONLY; | |
146 | ||
147 | s = bfd_make_section (abfd, ".plt"); | |
148 | if (s == NULL | |
149 | || ! bfd_set_section_flags (abfd, s, pltflags) | |
150 | || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) | |
b34976b6 | 151 | return FALSE; |
252b5132 RH |
152 | |
153 | if (bed->want_plt_sym) | |
154 | { | |
155 | /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the | |
156 | .plt section. */ | |
14a793b2 AM |
157 | struct elf_link_hash_entry *h; |
158 | struct bfd_link_hash_entry *bh = NULL; | |
159 | ||
252b5132 RH |
160 | if (! (_bfd_generic_link_add_one_symbol |
161 | (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, | |
b34976b6 | 162 | (bfd_vma) 0, (const char *) NULL, FALSE, |
14a793b2 | 163 | get_elf_backend_data (abfd)->collect, &bh))) |
b34976b6 | 164 | return FALSE; |
14a793b2 | 165 | h = (struct elf_link_hash_entry *) bh; |
252b5132 RH |
166 | h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; |
167 | h->type = STT_OBJECT; | |
168 | ||
169 | if (info->shared | |
170 | && ! _bfd_elf_link_record_dynamic_symbol (info, h)) | |
b34976b6 | 171 | return FALSE; |
252b5132 RH |
172 | } |
173 | ||
3e932841 | 174 | s = bfd_make_section (abfd, |
bf572ba0 | 175 | bed->default_use_rela_p ? ".rela.plt" : ".rel.plt"); |
252b5132 RH |
176 | if (s == NULL |
177 | || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) | |
178 | || ! bfd_set_section_alignment (abfd, s, ptralign)) | |
b34976b6 | 179 | return FALSE; |
252b5132 RH |
180 | |
181 | if (! _bfd_elf_create_got_section (abfd, info)) | |
b34976b6 | 182 | return FALSE; |
252b5132 | 183 | |
3018b441 RH |
184 | if (bed->want_dynbss) |
185 | { | |
186 | /* The .dynbss section is a place to put symbols which are defined | |
187 | by dynamic objects, are referenced by regular objects, and are | |
188 | not functions. We must allocate space for them in the process | |
189 | image and use a R_*_COPY reloc to tell the dynamic linker to | |
190 | initialize them at run time. The linker script puts the .dynbss | |
191 | section into the .bss section of the final image. */ | |
192 | s = bfd_make_section (abfd, ".dynbss"); | |
193 | if (s == NULL | |
194 | || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) | |
b34976b6 | 195 | return FALSE; |
252b5132 | 196 | |
3018b441 | 197 | /* The .rel[a].bss section holds copy relocs. This section is not |
252b5132 RH |
198 | normally needed. We need to create it here, though, so that the |
199 | linker will map it to an output section. We can't just create it | |
200 | only if we need it, because we will not know whether we need it | |
201 | until we have seen all the input files, and the first time the | |
202 | main linker code calls BFD after examining all the input files | |
203 | (size_dynamic_sections) the input sections have already been | |
204 | mapped to the output sections. If the section turns out not to | |
205 | be needed, we can discard it later. We will never need this | |
206 | section when generating a shared object, since they do not use | |
207 | copy relocs. */ | |
3018b441 RH |
208 | if (! info->shared) |
209 | { | |
3e932841 KH |
210 | s = bfd_make_section (abfd, |
211 | (bed->default_use_rela_p | |
212 | ? ".rela.bss" : ".rel.bss")); | |
3018b441 RH |
213 | if (s == NULL |
214 | || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) | |
215 | || ! bfd_set_section_alignment (abfd, s, ptralign)) | |
b34976b6 | 216 | return FALSE; |
3018b441 | 217 | } |
252b5132 RH |
218 | } |
219 | ||
b34976b6 | 220 | return TRUE; |
252b5132 RH |
221 | } |
222 | \f | |
252b5132 RH |
223 | /* Record a new dynamic symbol. We record the dynamic symbols as we |
224 | read the input files, since we need to have a list of all of them | |
225 | before we can determine the final sizes of the output sections. | |
226 | Note that we may actually call this function even though we are not | |
227 | going to output any dynamic symbols; in some cases we know that a | |
228 | symbol should be in the dynamic symbol table, but only if there is | |
229 | one. */ | |
230 | ||
b34976b6 | 231 | bfd_boolean |
252b5132 RH |
232 | _bfd_elf_link_record_dynamic_symbol (info, h) |
233 | struct bfd_link_info *info; | |
234 | struct elf_link_hash_entry *h; | |
235 | { | |
236 | if (h->dynindx == -1) | |
237 | { | |
2b0f7ef9 | 238 | struct elf_strtab_hash *dynstr; |
252b5132 RH |
239 | char *p, *alc; |
240 | const char *name; | |
b34976b6 | 241 | bfd_boolean copy; |
252b5132 RH |
242 | bfd_size_type indx; |
243 | ||
7a13edea NC |
244 | /* XXX: The ABI draft says the linker must turn hidden and |
245 | internal symbols into STB_LOCAL symbols when producing the | |
246 | DSO. However, if ld.so honors st_other in the dynamic table, | |
247 | this would not be necessary. */ | |
248 | switch (ELF_ST_VISIBILITY (h->other)) | |
249 | { | |
250 | case STV_INTERNAL: | |
251 | case STV_HIDDEN: | |
9d6eee78 L |
252 | if (h->root.type != bfd_link_hash_undefined |
253 | && h->root.type != bfd_link_hash_undefweak) | |
38048eb9 L |
254 | { |
255 | h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL; | |
b34976b6 | 256 | return TRUE; |
7a13edea | 257 | } |
0444bdd4 | 258 | |
7a13edea NC |
259 | default: |
260 | break; | |
261 | } | |
262 | ||
252b5132 RH |
263 | h->dynindx = elf_hash_table (info)->dynsymcount; |
264 | ++elf_hash_table (info)->dynsymcount; | |
265 | ||
266 | dynstr = elf_hash_table (info)->dynstr; | |
267 | if (dynstr == NULL) | |
268 | { | |
269 | /* Create a strtab to hold the dynamic symbol names. */ | |
2b0f7ef9 | 270 | elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); |
252b5132 | 271 | if (dynstr == NULL) |
b34976b6 | 272 | return FALSE; |
252b5132 RH |
273 | } |
274 | ||
275 | /* We don't put any version information in the dynamic string | |
aad5d350 | 276 | table. */ |
252b5132 RH |
277 | name = h->root.root.string; |
278 | p = strchr (name, ELF_VER_CHR); | |
279 | if (p == NULL) | |
280 | { | |
281 | alc = NULL; | |
b34976b6 | 282 | copy = FALSE; |
252b5132 RH |
283 | } |
284 | else | |
285 | { | |
d4c88bbb AM |
286 | size_t len = p - name + 1; |
287 | ||
288 | alc = bfd_malloc ((bfd_size_type) len); | |
252b5132 | 289 | if (alc == NULL) |
b34976b6 | 290 | return FALSE; |
d4c88bbb AM |
291 | memcpy (alc, name, len - 1); |
292 | alc[len - 1] = '\0'; | |
252b5132 | 293 | name = alc; |
b34976b6 | 294 | copy = TRUE; |
252b5132 RH |
295 | } |
296 | ||
2b0f7ef9 | 297 | indx = _bfd_elf_strtab_add (dynstr, name, copy); |
252b5132 RH |
298 | |
299 | if (alc != NULL) | |
300 | free (alc); | |
301 | ||
302 | if (indx == (bfd_size_type) -1) | |
b34976b6 | 303 | return FALSE; |
252b5132 RH |
304 | h->dynstr_index = indx; |
305 | } | |
306 | ||
b34976b6 | 307 | return TRUE; |
252b5132 | 308 | } |
42751cf3 | 309 | |
8c58d23b AM |
310 | /* Record a new local dynamic symbol. Returns 0 on failure, 1 on |
311 | success, and 2 on a failure caused by attempting to record a symbol | |
312 | in a discarded section, eg. a discarded link-once section symbol. */ | |
313 | ||
314 | int | |
315 | elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx) | |
316 | struct bfd_link_info *info; | |
317 | bfd *input_bfd; | |
318 | long input_indx; | |
319 | { | |
320 | bfd_size_type amt; | |
321 | struct elf_link_local_dynamic_entry *entry; | |
322 | struct elf_link_hash_table *eht; | |
323 | struct elf_strtab_hash *dynstr; | |
324 | unsigned long dynstr_index; | |
325 | char *name; | |
326 | Elf_External_Sym_Shndx eshndx; | |
327 | char esym[sizeof (Elf64_External_Sym)]; | |
328 | ||
329 | if (! is_elf_hash_table (info)) | |
330 | return 0; | |
331 | ||
332 | /* See if the entry exists already. */ | |
333 | for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next) | |
334 | if (entry->input_bfd == input_bfd && entry->input_indx == input_indx) | |
335 | return 1; | |
336 | ||
337 | amt = sizeof (*entry); | |
338 | entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt); | |
339 | if (entry == NULL) | |
340 | return 0; | |
341 | ||
342 | /* Go find the symbol, so that we can find it's name. */ | |
343 | if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr, | |
344 | (size_t) 1, (size_t) input_indx, | |
345 | &entry->isym, esym, &eshndx)) | |
346 | { | |
347 | bfd_release (input_bfd, entry); | |
348 | return 0; | |
349 | } | |
350 | ||
351 | if (entry->isym.st_shndx != SHN_UNDEF | |
352 | && (entry->isym.st_shndx < SHN_LORESERVE | |
353 | || entry->isym.st_shndx > SHN_HIRESERVE)) | |
354 | { | |
355 | asection *s; | |
356 | ||
357 | s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx); | |
358 | if (s == NULL || bfd_is_abs_section (s->output_section)) | |
359 | { | |
360 | /* We can still bfd_release here as nothing has done another | |
361 | bfd_alloc. We can't do this later in this function. */ | |
362 | bfd_release (input_bfd, entry); | |
363 | return 2; | |
364 | } | |
365 | } | |
366 | ||
367 | name = (bfd_elf_string_from_elf_section | |
368 | (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link, | |
369 | entry->isym.st_name)); | |
370 | ||
371 | dynstr = elf_hash_table (info)->dynstr; | |
372 | if (dynstr == NULL) | |
373 | { | |
374 | /* Create a strtab to hold the dynamic symbol names. */ | |
375 | elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); | |
376 | if (dynstr == NULL) | |
377 | return 0; | |
378 | } | |
379 | ||
b34976b6 | 380 | dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE); |
8c58d23b AM |
381 | if (dynstr_index == (unsigned long) -1) |
382 | return 0; | |
383 | entry->isym.st_name = dynstr_index; | |
384 | ||
385 | eht = elf_hash_table (info); | |
386 | ||
387 | entry->next = eht->dynlocal; | |
388 | eht->dynlocal = entry; | |
389 | entry->input_bfd = input_bfd; | |
390 | entry->input_indx = input_indx; | |
391 | eht->dynsymcount++; | |
392 | ||
393 | /* Whatever binding the symbol had before, it's now local. */ | |
394 | entry->isym.st_info | |
395 | = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info)); | |
396 | ||
397 | /* The dynindx will be set at the end of size_dynamic_sections. */ | |
398 | ||
399 | return 1; | |
400 | } | |
401 | ||
30b30c21 | 402 | /* Return the dynindex of a local dynamic symbol. */ |
42751cf3 | 403 | |
30b30c21 RH |
404 | long |
405 | _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx) | |
406 | struct bfd_link_info *info; | |
407 | bfd *input_bfd; | |
408 | long input_indx; | |
409 | { | |
410 | struct elf_link_local_dynamic_entry *e; | |
411 | ||
412 | for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) | |
413 | if (e->input_bfd == input_bfd && e->input_indx == input_indx) | |
414 | return e->dynindx; | |
415 | return -1; | |
416 | } | |
417 | ||
418 | /* This function is used to renumber the dynamic symbols, if some of | |
419 | them are removed because they are marked as local. This is called | |
420 | via elf_link_hash_traverse. */ | |
421 | ||
b34976b6 | 422 | static bfd_boolean elf_link_renumber_hash_table_dynsyms |
30b30c21 RH |
423 | PARAMS ((struct elf_link_hash_entry *, PTR)); |
424 | ||
b34976b6 | 425 | static bfd_boolean |
30b30c21 | 426 | elf_link_renumber_hash_table_dynsyms (h, data) |
42751cf3 | 427 | struct elf_link_hash_entry *h; |
30b30c21 | 428 | PTR data; |
42751cf3 | 429 | { |
30b30c21 RH |
430 | size_t *count = (size_t *) data; |
431 | ||
e92d460e AM |
432 | if (h->root.type == bfd_link_hash_warning) |
433 | h = (struct elf_link_hash_entry *) h->root.u.i.link; | |
434 | ||
42751cf3 | 435 | if (h->dynindx != -1) |
30b30c21 RH |
436 | h->dynindx = ++(*count); |
437 | ||
b34976b6 | 438 | return TRUE; |
42751cf3 | 439 | } |
30b30c21 | 440 | |
062e2358 | 441 | /* Assign dynsym indices. In a shared library we generate a section |
30b30c21 RH |
442 | symbol for each output section, which come first. Next come all of |
443 | the back-end allocated local dynamic syms, followed by the rest of | |
444 | the global symbols. */ | |
445 | ||
446 | unsigned long | |
447 | _bfd_elf_link_renumber_dynsyms (output_bfd, info) | |
448 | bfd *output_bfd; | |
449 | struct bfd_link_info *info; | |
450 | { | |
451 | unsigned long dynsymcount = 0; | |
452 | ||
453 | if (info->shared) | |
454 | { | |
455 | asection *p; | |
456 | for (p = output_bfd->sections; p ; p = p->next) | |
bc0ba537 AM |
457 | if ((p->flags & SEC_EXCLUDE) == 0) |
458 | elf_section_data (p)->dynindx = ++dynsymcount; | |
30b30c21 RH |
459 | } |
460 | ||
461 | if (elf_hash_table (info)->dynlocal) | |
462 | { | |
463 | struct elf_link_local_dynamic_entry *p; | |
464 | for (p = elf_hash_table (info)->dynlocal; p ; p = p->next) | |
465 | p->dynindx = ++dynsymcount; | |
466 | } | |
467 | ||
468 | elf_link_hash_traverse (elf_hash_table (info), | |
469 | elf_link_renumber_hash_table_dynsyms, | |
470 | &dynsymcount); | |
471 | ||
472 | /* There is an unused NULL entry at the head of the table which | |
473 | we must account for in our count. Unless there weren't any | |
474 | symbols, which means we'll have no table at all. */ | |
475 | if (dynsymcount != 0) | |
476 | ++dynsymcount; | |
477 | ||
478 | return elf_hash_table (info)->dynsymcount = dynsymcount; | |
479 | } | |
252b5132 | 480 | \f |
30b30c21 RH |
481 | /* Create a special linker section, or return a pointer to a linker |
482 | section already created */ | |
252b5132 RH |
483 | |
484 | elf_linker_section_t * | |
485 | _bfd_elf_create_linker_section (abfd, info, which, defaults) | |
486 | bfd *abfd; | |
487 | struct bfd_link_info *info; | |
488 | enum elf_linker_section_enum which; | |
489 | elf_linker_section_t *defaults; | |
490 | { | |
491 | bfd *dynobj = elf_hash_table (info)->dynobj; | |
492 | elf_linker_section_t *lsect; | |
493 | ||
494 | /* Record the first bfd section that needs the special section */ | |
495 | if (!dynobj) | |
496 | dynobj = elf_hash_table (info)->dynobj = abfd; | |
497 | ||
498 | /* If this is the first time, create the section */ | |
499 | lsect = elf_linker_section (dynobj, which); | |
500 | if (!lsect) | |
501 | { | |
502 | asection *s; | |
dc810e39 | 503 | bfd_size_type amt = sizeof (elf_linker_section_t); |
252b5132 | 504 | |
dc810e39 | 505 | lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt); |
252b5132 RH |
506 | |
507 | *lsect = *defaults; | |
508 | elf_linker_section (dynobj, which) = lsect; | |
509 | lsect->which = which; | |
b34976b6 | 510 | lsect->hole_written_p = FALSE; |
252b5132 RH |
511 | |
512 | /* See if the sections already exist */ | |
513 | lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name); | |
514 | if (!s || (s->flags & defaults->flags) != defaults->flags) | |
515 | { | |
516 | lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name); | |
517 | ||
518 | if (s == NULL) | |
519 | return (elf_linker_section_t *)0; | |
520 | ||
521 | bfd_set_section_flags (dynobj, s, defaults->flags); | |
522 | bfd_set_section_alignment (dynobj, s, lsect->alignment); | |
523 | } | |
524 | else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment) | |
525 | bfd_set_section_alignment (dynobj, s, lsect->alignment); | |
526 | ||
527 | s->_raw_size = align_power (s->_raw_size, lsect->alignment); | |
528 | ||
aad5d350 AM |
529 | /* Is there a hole we have to provide? If so check whether the |
530 | segment is too big already */ | |
252b5132 RH |
531 | if (lsect->hole_size) |
532 | { | |
533 | lsect->hole_offset = s->_raw_size; | |
534 | s->_raw_size += lsect->hole_size; | |
535 | if (lsect->hole_offset > lsect->max_hole_offset) | |
536 | { | |
aad5d350 AM |
537 | (*_bfd_error_handler) |
538 | (_("%s: Section %s is too large to add hole of %ld bytes"), | |
539 | bfd_get_filename (abfd), | |
540 | lsect->name, | |
541 | (long) lsect->hole_size); | |
252b5132 RH |
542 | |
543 | bfd_set_error (bfd_error_bad_value); | |
544 | return (elf_linker_section_t *)0; | |
545 | } | |
546 | } | |
547 | ||
548 | #ifdef DEBUG | |
549 | fprintf (stderr, "Creating section %s, current size = %ld\n", | |
550 | lsect->name, (long)s->_raw_size); | |
551 | #endif | |
552 | ||
553 | if (lsect->sym_name) | |
554 | { | |
14a793b2 AM |
555 | struct elf_link_hash_entry *h; |
556 | struct bfd_link_hash_entry *bh; | |
557 | ||
252b5132 RH |
558 | #ifdef DEBUG |
559 | fprintf (stderr, "Adding %s to section %s\n", | |
560 | lsect->sym_name, | |
561 | lsect->name); | |
562 | #endif | |
14a793b2 | 563 | bh = bfd_link_hash_lookup (info->hash, lsect->sym_name, |
b34976b6 | 564 | FALSE, FALSE, FALSE); |
14a793b2 AM |
565 | |
566 | if ((bh == NULL || bh->type == bfd_link_hash_undefined) | |
567 | && !(_bfd_generic_link_add_one_symbol | |
568 | (info, abfd, lsect->sym_name, BSF_GLOBAL, s, | |
569 | (lsect->hole_size | |
570 | ? s->_raw_size - lsect->hole_size + lsect->sym_offset | |
571 | : lsect->sym_offset), | |
b34976b6 | 572 | (const char *) NULL, FALSE, |
14a793b2 AM |
573 | get_elf_backend_data (abfd)->collect, &bh))) |
574 | return (elf_linker_section_t *) 0; | |
575 | h = (struct elf_link_hash_entry *) bh; | |
252b5132 RH |
576 | |
577 | if ((defaults->which != LINKER_SECTION_SDATA) | |
578 | && (defaults->which != LINKER_SECTION_SDATA2)) | |
579 | h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC; | |
580 | ||
581 | h->type = STT_OBJECT; | |
582 | lsect->sym_hash = h; | |
583 | ||
584 | if (info->shared | |
585 | && ! _bfd_elf_link_record_dynamic_symbol (info, h)) | |
14a793b2 | 586 | return (elf_linker_section_t *) 0; |
252b5132 RH |
587 | } |
588 | } | |
589 | ||
590 | #if 0 | |
591 | /* This does not make sense. The sections which may exist in the | |
592 | object file have nothing to do with the sections we want to | |
593 | create. */ | |
594 | ||
595 | /* Find the related sections if they have been created */ | |
596 | if (lsect->bss_name && !lsect->bss_section) | |
597 | lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name); | |
598 | ||
599 | if (lsect->rel_name && !lsect->rel_section) | |
600 | lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name); | |
601 | #endif | |
602 | ||
603 | return lsect; | |
604 | } | |
252b5132 RH |
605 | \f |
606 | /* Find a linker generated pointer with a given addend and type. */ | |
607 | ||
608 | elf_linker_section_pointers_t * | |
609 | _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which) | |
610 | elf_linker_section_pointers_t *linker_pointers; | |
dc810e39 | 611 | bfd_vma addend; |
252b5132 RH |
612 | elf_linker_section_enum_t which; |
613 | { | |
614 | for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) | |
615 | { | |
616 | if (which == linker_pointers->which && addend == linker_pointers->addend) | |
617 | return linker_pointers; | |
618 | } | |
619 | ||
620 | return (elf_linker_section_pointers_t *)0; | |
621 | } | |
252b5132 RH |
622 | \f |
623 | /* Make the .rela section corresponding to the generated linker section. */ | |
624 | ||
b34976b6 | 625 | bfd_boolean |
252b5132 RH |
626 | _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment) |
627 | bfd *dynobj; | |
628 | elf_linker_section_t *lsect; | |
629 | int alignment; | |
630 | { | |
631 | if (lsect->rel_section) | |
b34976b6 | 632 | return TRUE; |
252b5132 RH |
633 | |
634 | lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name); | |
635 | if (lsect->rel_section == NULL) | |
636 | { | |
637 | lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name); | |
638 | if (lsect->rel_section == NULL | |
639 | || ! bfd_set_section_flags (dynobj, | |
640 | lsect->rel_section, | |
641 | (SEC_ALLOC | |
642 | | SEC_LOAD | |
643 | | SEC_HAS_CONTENTS | |
644 | | SEC_IN_MEMORY | |
645 | | SEC_LINKER_CREATED | |
646 | | SEC_READONLY)) | |
647 | || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment)) | |
b34976b6 | 648 | return FALSE; |
252b5132 RH |
649 | } |
650 | ||
b34976b6 | 651 | return TRUE; |
252b5132 | 652 | } |