1 /* Copyright (C) 2001, 2002, 2003, 2005, 2006, 2008, 2009 Red Hat, Inc.
2 This file is part of Red Hat elfutils.
3 Written by Ulrich Drepper <drepper@redhat.com>, 2001.
4
5 Red Hat elfutils is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by the
7 Free Software Foundation; version 2 of the License.
8
9 Red Hat elfutils is distributed in the hope that it will be useful, but
10 WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 General Public License for more details.
13
14 You should have received a copy of the GNU General Public License along
15 with Red Hat elfutils; if not, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
17
18 Red Hat elfutils is an included package of the Open Invention Network.
19 An included package of the Open Invention Network is a package for which
20 Open Invention Network licensees cross-license their patents. No patent
21 license is granted, either expressly or impliedly, by designation as an
22 included package. Should you wish to participate in the Open Invention
23 Network licensing program, please visit www.openinventionnetwork.com
24 <http://www.openinventionnetwork.com>. */
25
26 #ifndef LD_H
27 #define LD_H 1
28
29 #include <dlfcn.h>
30 #include <obstack.h>
31 #include <stdbool.h>
32 #include <stdio.h>
33 #include "xelf.h"
34
35
36 /* Recommended size of the buffer passed to ld_strerror. */
37 #define ERRBUFSIZE (512)
38
39 /* Character used to introduce version name after symbol. */
40 #define VER_CHR '@'
41
42
43 /* Methods for handling archives. */
44 enum extract_rule
45 {
46 defaultextract, /* Weak references don't cause archive member to
47 be used. */
48 weakextract, /* Weak references cause archive member to be
49 extracted. */
50 allextract /* Extract all archive members regardless of
51 references (aka whole-archive). */
52 };
53
54
55 /* Type of output file. */
56 enum file_type
57 {
58 no_file_type = 0, /* None selected so far. */
59 executable_file_type, /* Executable. */
60 dso_file_type, /* DSO. */
61 dso_needed_file_type, /* DSO introduced by DT_NEEDED. */
62 relocatable_file_type, /* Relocatable object file. */
63 archive_file_type /* Archive (input only). */
64 };
65
66
67 struct usedfiles
68 {
69 /* The next file given at the command line. */
70 struct usedfiles *next;
71 /* Nonzero if this file is the beginning of a group. */
72 bool group_start;
73 /* Nonzero if this file is the end of a group. */
74 bool group_end;
75 /* Pointer to the beginning of the group. It is necessary to
76 explain why we cannot simply use the 'next' pointer and have a
77 circular single-linked list like in many cases. The problem is
78 that the last archive of the group, if it is the last file of the
79 group, contains the only existing pointer to the next file we
80 have to look at. All files are initially connected via the
81 'next' pointer in a single-linked list. Therefore we cannot
82 overwrite this value. It instead will be used once the group is
83 handled and we go on processing the rest of the files. */
84 struct usedfiles *group_backref;
85
86 /* Name/path of the file. */
87 const char *fname;
88 /* Resolved file name. */
89 const char *rfname;
90 /* Name used as reference in DT_NEEDED entries. This is normally
91 the SONAME. If it is missing it's normally the fname above. */
92 const char *soname;
93 /* Handle for the SONAME in the string table. */
94 struct Ebl_Strent *sonameent;
95
96 /* Help to identify duplicates. */
97 dev_t dev;
98 ino_t ino;
99
100 enum
101 {
102 not_opened,
103 opened,
104 in_archive,
105 closed
106 } status;
107
108 /* How to extract elements from archives. */
109 enum extract_rule extract_rule;
110
111 /* Lazy-loading rule. */
112 bool lazyload;
113
114 /* If this is a DSO the flag indicates whether the file is directly
115 used in a reference. */
116 bool used;
117
118 /* True when file should be added to DT_NEEDED list only when
119 directly referenced. */
120 bool as_needed;
121
122 /* If nonzero this is the archive sequence number which can be used to
123 determine whether back refernces from -( -) or GROUP statements
124 have to be followed. */
125 int archive_seq;
126
127 /* Pointer to the record for the archive containing this file. */
128 struct usedfiles *archive_file;
129
130 /* Type of file. We have to distinguish these types since they
131 are searched for differently. */
132 enum file_type file_type;
133 /* This is the ELF library handle for this file. */
134 Elf *elf;
135
136 /* The ELF header. */
137 #if NATIVE_ELF != 0
138 XElf_Ehdr *ehdr;
139 # define FILEINFO_EHDR(fi) (*(fi))
140 #else
141 XElf_Ehdr ehdr;
142 # define FILEINFO_EHDR(fi) (fi)
143 #endif
144
145 /* Index of the section header string table section. We use a
146 separate field and not the e_shstrndx field in the ELF header
147 since in case of a file with more than 64000 sections the index
148 might be stored in the section header of section zero. The
149 elf_getshdrstrndx() function can find the value but it is too
150 costly to repeat this call over and over. */
151 size_t shstrndx;
152
153 /* Info about the sections of the file. */
154 struct scninfo
155 {
156 /* Handle for the section. Note that we can store a section
157 handle here because the file is not changing. This together
158 with the knowledge about the libelf library is enough for us to
159 assume the section reference remains valid at all times. */
160 Elf_Scn *scn;
161 /* Section header. */
162 #if NATIVE_ELF != 0
163 XElf_Shdr *shdr;
164 # define SCNINFO_SHDR(si) (*(si))
165 #else
166 XElf_Shdr shdr;
167 # define SCNINFO_SHDR(si) (si)
168 #endif
169 /* Offset of this files section in the combined section. */
170 XElf_Off offset;
171 /* Index of the section in the output file. */
172 Elf32_Word outscnndx;
173 /* Index of the output section in the 'allsection' array. */
174 Elf32_Word allsectionsidx;
175 /* True if the section is used. */
176 bool used;
177 /* True if section is an unused COMDAT section. */
178 bool unused_comdat;
179 /* True if this is a COMDAT group section. */
180 bool comdat_group;
181 /* Section group number. This is the index of the SHT_GROUP section. */
182 Elf32_Word grpid;
183 /* Pointer back to the containing file information structure. */
184 struct usedfiles *fileinfo;
185 /* List of symbols in this section (set only for merge-able sections
186 and group sections). */
187 struct symbol *symbols;
188 /* Size of relocations in this section. Only used for relocation
189 sections. */
190 size_t relsize;
191 /* Pointer to next section which is put in the given output
192 section. */
193 struct scninfo *next;
194 } *scninfo;
195
196 /* List of section group sections. */
197 struct scninfo *groups;
198
199 /* The symbol table section.
200
201 XXX Maybe support for more than one symbol table is needed. */
202 Elf_Data *symtabdata;
203 /* Extra section index table section. */
204 Elf_Data *xndxdata;
205 /* Dynamic symbol table section. */
206 Elf_Data *dynsymtabdata;
207 /* The version number section. */
208 Elf_Data *versymdata;
209 /* The defined versions. */
210 Elf_Data *verdefdata;
211 /* Number of versions defined. */
212 size_t nverdef;
213 /* True if the version with the given index number is used in the
214 output. */
215 XElf_Versym *verdefused;
216 /* How many versions are used. */
217 size_t nverdefused;
218 /* Handle for name of the version. */
219 struct Ebl_Strent **verdefent;
220 /* The needed versions. */
221 Elf_Data *verneeddata;
222 /* String table section associated with the symbol table. */
223 Elf32_Word symstridx;
224 /* String table section associated with the dynamic symbol table. */
225 Elf32_Word dynsymstridx;
226 /* Number of entries in the symbol table. */
227 size_t nsymtab;
228 size_t nlocalsymbols;
229 size_t ndynsymtab;
230 /* Dynamic section. */
231 Elf_Scn *dynscn;
232
233 /* Indirection table for the symbols defined here. */
234 Elf32_Word *symindirect;
235 Elf32_Word *dynsymindirect;
236 /* For undefined or common symbols we need a reference to the symbol
237 record. */
238 struct symbol **symref;
239 struct symbol **dynsymref;
240
241 /* This is the file descriptor. The value is -1 if the descriptor
242 was already closed. This can happen if we needed file descriptors
243 to open new files. */
244 int fd;
245 /* This flag is true if the descriptor was passed to the generic
246 functions from somewhere else. This is an implementation detail;
247 no machine-specific code must use this flag. */
248 bool fd_passed;
249
250 /* True if any of the sections is merge-able. */
251 bool has_merge_sections;
252 };
253
254
255 /* Functions to test for the various types of files we handle. */
256 static inline int
ld_file_rel_p(struct usedfiles * file)257 ld_file_rel_p (struct usedfiles *file)
258 {
259 return (elf_kind (file->elf) == ELF_K_ELF
260 && FILEINFO_EHDR (file->ehdr).e_type == ET_REL);
261 }
262
263 static inline int
ld_file_dso_p(struct usedfiles * file)264 ld_file_dso_p (struct usedfiles *file)
265 {
266 return (elf_kind (file->elf) == ELF_K_ELF
267 && FILEINFO_EHDR (file->ehdr).e_type == ET_DYN);
268 }
269
270 static inline int
ld_file_ar_p(struct usedfiles * file)271 ld_file_ar_p (struct usedfiles *file)
272 {
273 return elf_kind (file->elf) == ELF_K_AR;
274 }
275
276
277 struct pathelement
278 {
279 /* The next path to search. */
280 struct pathelement *next;
281 /* The path name. */
282 const char *pname;
283 /* Larger than zero if the directory exists, smaller than zero if not,
284 zero if it is not yet known. */
285 int exist;
286 };
287
288
289 /* Forward declaration. */
290 struct ld_state;
291
292
293 /* Callback functions. */
294 struct callbacks
295 {
296 /* Library names passed to the linker as -lXXX represent files named
297 libXXX.YY. The YY part can have different forms, depending on the
298 architecture. The generic set is .so and .a (in this order). */
299 const char **(*lib_extensions) (struct ld_state *)
300 __attribute__ ((__const__));
301 #define LIB_EXTENSION(state) \
302 DL_CALL_FCT ((state)->callbacks.lib_extensions, (state))
303
304 /* Process the given file. If the file is not yet open, open it.
305 The first parameter is a file descriptor for the file which can
306 be -1 to indicate the file has not yet been found. The second
307 parameter describes the file to be opened, the last one is the
308 state of the linker which among other information contain the
309 paths we look at.*/
310 int (*file_process) (int fd, struct usedfiles *, struct ld_state *,
311 struct usedfiles **);
312 #define FILE_PROCESS(fd, file, state, nextp) \
313 DL_CALL_FCT ((state)->callbacks.file_process, (fd, file, state, nextp))
314
315 /* Close the given file. */
316 int (*file_close) (struct usedfiles *, struct ld_state *);
317 #define FILE_CLOSE(file, state) \
318 DL_CALL_FCT ((state)->callbacks.file_close, (file, state))
319
320 /* Create the output sections now. This requires knowledge about
321 all the sections we will need. It may be necessary to sort the
322 sections in the order they are supposed to appear in the
323 executable. The sorting use many different kinds of information
324 to optimize the resulting binary. Important is to respect
325 segment boundaries and the needed alignment. The mode of the
326 segments will be determined afterwards automatically by the
327 output routines. */
328 void (*create_sections) (struct ld_state *);
329 #define CREATE_SECTIONS(state) \
330 DL_CALL_FCT ((state)->callbacks.create_sections, (state))
331
332 /* Determine whether we have any non-weak unresolved references left. */
333 int (*flag_unresolved) (struct ld_state *);
334 #define FLAG_UNRESOLVED(state) \
335 DL_CALL_FCT ((state)->callbacks.flag_unresolved, (state))
336
337 /* Create the sections which are generated by the linker and are not
338 present in the input file. */
339 void (*generate_sections) (struct ld_state *);
340 #define GENERATE_SECTIONS(state) \
341 DL_CALL_FCT ((state)->callbacks.generate_sections, (state))
342
343 /* Open the output file. The file name is given or "a.out". We
344 create as much of the ELF structure as possible. */
345 int (*open_outfile) (struct ld_state *, int, int, int);
346 #define OPEN_OUTFILE(state, machine, class, data) \
347 DL_CALL_FCT ((state)->callbacks.open_outfile, (state, machine, class, data))
348
349 /* Create the data for the output file. */
350 int (*create_outfile) (struct ld_state *);
351 #define CREATE_OUTFILE(state) \
352 DL_CALL_FCT ((state)->callbacks.create_outfile, (state))
353
354 /* Process a relocation section. */
355 void (*relocate_section) (struct ld_state *, Elf_Scn *, struct scninfo *,
356 const Elf32_Word *);
357 #define RELOCATE_SECTION(state, outscn, first, dblindirect) \
358 DL_CALL_FCT ((state)->callbacks.relocate_section, (state, outscn, first, \
359 dblindirect))
360
361 /* Allocate a data buffer for the relocations of the given output
362 section. */
363 void (*count_relocations) (struct ld_state *, struct scninfo *);
364 #define COUNT_RELOCATIONS(state, scninfo) \
365 DL_CALL_FCT ((state)->callbacks.count_relocations, (state, scninfo))
366
367 /* Create relocations for executable or DSO. */
368 void (*create_relocations) (struct ld_state *, const Elf32_Word *);
369 #define CREATE_RELOCATIONS(state, dlbindirect) \
370 DL_CALL_FCT ((state)->callbacks.create_relocations, (state, dblindirect))
371
372 /* Finalize the output file. */
373 int (*finalize) (struct ld_state *);
374 #define FINALIZE(state) \
375 DL_CALL_FCT ((state)->callbacks.finalize, (state))
376
377 /* Check whether special section number is known. */
378 bool (*special_section_number_p) (struct ld_state *, size_t);
379 #define SPECIAL_SECTION_NUMBER_P(state, number) \
380 DL_CALL_FCT ((state)->callbacks.special_section_number_p, (state, number))
381
382 /* Check whether section type is known. */
383 bool (*section_type_p) (struct ld_state *, XElf_Word);
384 #define SECTION_TYPE_P(state, type) \
385 DL_CALL_FCT ((state)->callbacks.section_type_p, (state, type))
386
387 /* Return section flags for .dynamic section. */
388 XElf_Xword (*dynamic_section_flags) (struct ld_state *);
389 #define DYNAMIC_SECTION_FLAGS(state) \
390 DL_CALL_FCT ((state)->callbacks.dynamic_section_flags, (state))
391
392 /* Create the data structures for the .plt section and initialize it. */
393 void (*initialize_plt) (struct ld_state *, Elf_Scn *scn);
394 #define INITIALIZE_PLT(state, scn) \
395 DL_CALL_FCT ((state)->callbacks.initialize_plt, (state, scn))
396
397 /* Create the data structures for the .rel.plt section and initialize it. */
398 void (*initialize_pltrel) (struct ld_state *, Elf_Scn *scn);
399 #define INITIALIZE_PLTREL(state, scn) \
400 DL_CALL_FCT ((state)->callbacks.initialize_pltrel, (state, scn))
401
402 /* Finalize the .plt section the what belongs to them. */
403 void (*finalize_plt) (struct ld_state *, size_t, size_t, struct symbol **);
404 #define FINALIZE_PLT(state, nsym, nsym_dyn, ndxtosym) \
405 DL_CALL_FCT ((state)->callbacks.finalize_plt, (state, nsym, nsym_dyn, \
406 ndxtosym))
407
408 /* Create the data structures for the .got section and initialize it. */
409 void (*initialize_got) (struct ld_state *, Elf_Scn *scn);
410 #define INITIALIZE_GOT(state, scn) \
411 DL_CALL_FCT ((state)->callbacks.initialize_got, (state, scn))
412
413 /* Create the data structures for the .got.plt section and initialize it. */
414 void (*initialize_gotplt) (struct ld_state *, Elf_Scn *scn);
415 #define INITIALIZE_GOTPLT(state, scn) \
416 DL_CALL_FCT ((state)->callbacks.initialize_gotplt, (state, scn))
417
418 /* Return the tag corresponding to the native relocation type for
419 the platform. */
420 int (*rel_type) (struct ld_state *);
421 #define REL_TYPE(state) \
422 DL_CALL_FCT ((state)->callbacks.rel_type, (state))
423 };
424
425
426 /* Structure for symbol representation. This data structure is used a
427 lot, so size is important. */
428 struct symbol
429 {
430 /* Symbol name. */
431 const char *name;
432 /* Size of the object. */
433 XElf_Xword size;
434 /* Index of the symbol in the symbol table of the object. */
435 size_t symidx;
436 /* Index of the symbol in the symbol table of the output file. */
437 size_t outsymidx;
438
439 /* Description where the symbol is found/needed. */
440 size_t scndx;
441 struct usedfiles *file;
442 /* Index of the symbol table. */
443 Elf32_Word symscndx;
444
445 /* Index of the symbol in the dynamic symbol table of the output
446 file. Note that the value only needs to be 16 bit wide since
447 there cannot be more sections in an executable or DSO. */
448 unsigned int outdynsymidx:16;
449
450 /* Type of the symbol. */
451 unsigned int type:4;
452 /* Various flags. */
453 unsigned int defined:1;
454 unsigned int common:1;
455 unsigned int weak:1;
456 unsigned int added:1;
457 unsigned int merged:1;
458 unsigned int local:1;
459 unsigned int hidden:1;
460 /* Nonzero if the symbol is on the from_dso list. */
461 unsigned int on_dsolist:1;
462 /* Nonzero if symbol needs copy relocation, reset when the
463 relocation has been created. */
464 unsigned int need_copy:1;
465 unsigned int in_dso:1;
466
467 union
468 {
469 /* Pointer to the handle created by the functions which create
470 merged section contents. We use 'void *' because there are
471 different implementations used. */
472 void *handle;
473 XElf_Addr value;
474 } merge;
475
476 /* Pointer to next/previous symbol on whatever list the symbol is. */
477 struct symbol *next;
478 struct symbol *previous;
479 /* Pointer to next symbol of the same section (only set for merge-able
480 sections). */
481 struct symbol *next_in_scn;
482 };
483
484
485 /* Get the definition for the symbol table. */
486 #include <symbolhash.h>
487
488 /* Simple single linked list of file names. */
489 struct filename_list
490 {
491 const char *name;
492 struct usedfiles *real;
493 struct filename_list *next;
494 bool group_start;
495 bool group_end;
496 bool as_needed;
497 };
498
499
500 /* Data structure to describe expression in linker script. */
501 struct expression
502 {
503 enum expression_tag
504 {
505 exp_num,
506 exp_sizeof_headers,
507 exp_pagesize,
508 exp_id,
509 exp_mult,
510 exp_div,
511 exp_mod,
512 exp_plus,
513 exp_minus,
514 exp_and,
515 exp_or,
516 exp_align
517 } tag;
518
519 union
520 {
521 uintmax_t num;
522 struct expression *child;
523 struct
524 {
525 struct expression *left;
526 struct expression *right;
527 } binary;
528 const char *str;
529 } val;
530 };
531
532
533 /* Data structure for section name with flags. */
534 struct input_section_name
535 {
536 const char *name;
537 bool sort_flag;
538 };
539
540 /* File name mask with section name. */
541 struct filemask_section_name
542 {
543 const char *filemask;
544 const char *excludemask;
545 struct input_section_name *section_name;
546 bool keep_flag;
547 };
548
549 /* Data structure for assignments. */
550 struct assignment
551 {
552 const char *variable;
553 struct expression *expression;
554 struct symbol *sym;
555 bool provide_flag;
556 };
557
558
559 /* Data structure describing input for an output section. */
560 struct input_rule
561 {
562 enum
563 {
564 input_section,
565 input_assignment
566 } tag;
567
568 union
569 {
570 struct assignment *assignment;
571 struct filemask_section_name *section;
572 } val;
573
574 struct input_rule *next;
575 };
576
577
578 /* Data structure to describe output section. */
579 struct output_section
580 {
581 const char *name;
582 struct input_rule *input;
583 XElf_Addr max_alignment;
584 bool ignored;
585 };
586
587
588 /* Data structure to describe output file format. */
589 struct output_rule
590 {
591 enum
592 {
593 output_section,
594 output_assignment
595 } tag;
596
597 union
598 {
599 struct assignment *assignment;
600 struct output_section section;
601 } val;
602
603 struct output_rule *next;
604 };
605
606
607 /* List of all the segments the linker script describes. */
608 struct output_segment
609 {
610 int mode;
611 struct output_rule *output_rules;
612 struct output_segment *next;
613
614 XElf_Off offset;
615 XElf_Addr addr;
616 XElf_Xword align;
617 };
618
619
620 /* List of identifiers. */
621 struct id_list
622 {
623 union
624 {
625 enum id_type
626 {
627 id_str, /* Normal string. */
628 id_all, /* "*", matches all. */
629 id_wild /* Globbing wildcard string. */
630 } id_type;
631 struct
632 {
633 bool local;
634 const char *versionname;
635 } s;
636 } u;
637 const char *id;
638 struct id_list *next;
639 };
640
641
642 /* Version information. */
643 struct version
644 {
645 struct version *next;
646 struct id_list *local_names;
647 struct id_list *global_names;
648 const char *versionname;
649 const char *parentname;
650 };
651
652
653 /* Head for list of sections. */
654 struct scnhead
655 {
656 /* Name of the sections. */
657 const char *name;
658
659 /* Accumulated flags for the sections. */
660 XElf_Xword flags;
661
662 /* Type of the sections. */
663 XElf_Word type;
664
665 /* Entry size. If there are differencs between the sections with
666 the same name this field contains 1. */
667 XElf_Word entsize;
668
669 /* If non-NULL pointer to group signature. */
670 const char *grp_signature;
671
672 /* Maximum alignment for all sections. */
673 XElf_Word align;
674
675 /* Distinguish between normal sections coming from the input file
676 and sections generated by the linker. */
677 enum scn_kind
678 {
679 scn_normal, /* Section from the input file(s). */
680 scn_dot_interp, /* Generated .interp section. */
681 scn_dot_got, /* Generated .got section. */
682 scn_dot_gotplt, /* Generated .got.plt section. */
683 scn_dot_dynrel, /* Generated .rel.dyn section. */
684 scn_dot_dynamic, /* Generated .dynamic section. */
685 scn_dot_dynsym, /* Generated .dynsym section. */
686 scn_dot_dynstr, /* Generated .dynstr section. */
687 scn_dot_hash, /* Generated .hash section. */
688 scn_dot_gnu_hash, /* Generated .gnu.hash section. */
689 scn_dot_plt, /* Generated .plt section. */
690 scn_dot_pltrel, /* Generated .rel.plt section. */
691 scn_dot_version, /* Generated .gnu.version section. */
692 scn_dot_version_r, /* Generated .gnu.version_r section. */
693 scn_dot_note_gnu_build_id /* Generated .note.gnu.build-id section. */
694 } kind;
695
696 /* True is the section is used in the output. */
697 bool used;
698
699 /* Total size (only determined this way for relocation sections). */
700 size_t relsize;
701
702 /* Filled in by the section sorting to indicate which segment the
703 section goes in. */
704 int segment_nr;
705
706 /* Index of the output section. We cannot store the section handle
707 directly here since the handle is a pointer in a dynamically
708 allocated table which might move if it becomes too small for all
709 the sections. Using the index the correct value can be found at
710 all times. */
711 XElf_Word scnidx;
712
713 /* Index of the STT_SECTION entry for this section in the symbol
714 table. */
715 XElf_Word scnsymidx;
716
717 /* Address of the section in the output file. */
718 XElf_Addr addr;
719
720 /* Handle for the section name in the output file's section header
721 string table. */
722 struct Ebl_Strent *nameent;
723
724 /* Tail of list of symbols for this section. Only set if the
725 section is merge-able. */
726 struct symbol *symbols;
727
728 /* Pointer to last section. */
729 struct scninfo *last;
730 };
731
732
733 /* Define hash table for sections. */
734 #include <sectionhash.h>
735
736 /* Define hash table for version symbols. */
737 #include <versionhash.h>
738
739
740 /* State of the linker. */
741 struct ld_state
742 {
743 /* ELF backend library handle. */
744 Ebl *ebl;
745
746 /* List of all archives participating, in this order. */
747 struct usedfiles *archives;
748 /* End of the list. */
749 struct usedfiles *tailarchives;
750 /* If nonzero we are looking for the beginning of a group. */
751 bool group_start_requested;
752 /* Pointer to the archive starting the group. */
753 struct usedfiles *group_start_archive;
754
755 /* List of the DSOs we found. */
756 struct usedfiles *dsofiles;
757 /* Number of DSO files. */
758 size_t ndsofiles;
759 /* Ultimate list of object files which are linked in. */
760 struct usedfiles *relfiles;
761
762 /* List the DT_NEEDED DSOs. */
763 struct usedfiles *needed;
764
765 /* Temporary storage for the parser. */
766 struct filename_list *srcfiles;
767
768 /* List of all the paths to look at. */
769 struct pathelement *paths;
770 /* Tail of the list. */
771 struct pathelement *tailpaths;
772
773 /* User provided paths for lookup of DSOs. */
774 struct pathelement *rpath;
775 struct pathelement *rpath_link;
776 struct pathelement *runpath;
777 struct pathelement *runpath_link;
778 struct Ebl_Strent *rxxpath_strent;
779 int rxxpath_tag;
780
781 /* From the environment variable LD_LIBRARY_PATH. */
782 struct pathelement *ld_library_path1;
783 struct pathelement *ld_library_path2;
784
785 /* Name of the output file. */
786 const char *outfname;
787 /* Name of the temporary file we initially create. */
788 const char *tempfname;
789 /* File descriptor opened for the output file. */
790 int outfd;
791 /* The ELF descriptor for the output file. */
792 Elf *outelf;
793
794 /* Type of output file. */
795 enum file_type file_type;
796
797 /* Is this a system library or not. */
798 bool is_system_library;
799
800 /* Page size to be assumed for the binary. */
801 size_t pagesize;
802
803 /* Name of the interpreter for dynamically linked objects. */
804 const char *interp;
805 /* Index of the .interp section. */
806 Elf32_Word interpscnidx;
807
808 /* Optimization level. */
809 unsigned long int optlevel;
810
811 /* If true static linking is requested. */
812 bool statically;
813
814 /* If true, add DT_NEEDED entries for following files if they are
815 needed. */
816 bool as_needed;
817
818 /* How to extract elements from archives. */
819 enum extract_rule extract_rule;
820
821 /* Sequence number of the last archive we used. */
822 int last_archive_used;
823
824 /* If true print to stdout information about the files we are
825 trying to open. */
826 bool trace_files;
827
828 /* If true multiple definitions are not considered an error; the
829 first is used. */
830 bool muldefs;
831
832 /* If true undefined symbols when building DSOs are not fatal. */
833 bool nodefs;
834
835 /* If true add line indentifying link-editor to .comment section. */
836 bool add_ld_comment;
837
838 /* Stripping while linking. */
839 enum
840 {
841 strip_none,
842 strip_debug,
843 strip_all,
844 strip_everything
845 } strip;
846
847 /* The callback function vector. */
848 struct callbacks callbacks;
849
850 /* Name of the entry symbol. Can also be a numeric value. */
851 const char *entry;
852
853 /* The description of the segments in the output file. */
854 struct output_segment *output_segments;
855
856 /* List of the symbols we created from linker script definitions. */
857 struct symbol *lscript_syms;
858 size_t nlscript_syms;
859
860 /* Table with known symbols. */
861 ld_symbol_tab symbol_tab;
862
863 /* Table with used sections. */
864 ld_section_tab section_tab;
865
866 /* The list of sections once we collected them. */
867 struct scnhead **allsections;
868 size_t nallsections;
869 size_t nusedsections;
870 size_t nnotesections;
871
872 /* Beginning of the list of symbols which are still unresolved. */
873 struct symbol *unresolved;
874 /* Number of truely unresolved entries in the list. */
875 size_t nunresolved;
876 /* Number of truely unresolved, non-weak entries in the list. */
877 size_t nunresolved_nonweak;
878
879 /* List of common symbols. */
880 struct symbol *common_syms;
881 /* Section for the common symbols. */
882 struct scninfo *common_section;
883
884 /* List of symbols defined in DSOs and used in a relocatable file.
885 DSO symbols not referenced in the relocatable files are not on
886 the list. If a symbol is on the list the on_dsolist field in the
887 'struct symbol' is nonzero. */
888 struct symbol *from_dso;
889 /* Number of entries in from_dso. */
890 size_t nfrom_dso;
891 /* Number of entries in the dynamic symbol table. */
892 size_t ndynsym;
893 /* Number of PLT entries from DSO references. */
894 size_t nplt;
895 /* Number of PLT entries from DSO references. */
896 size_t ngot;
897 /* Number of copy relocations. */
898 size_t ncopy;
899 /* Section for copy relocations. */
900 struct scninfo *copy_section;
901
902 /* Keeping track of the number of symbols in the output file. */
903 size_t nsymtab;
904 size_t nlocalsymbols;
905
906 /* Special symbols. */
907 struct symbol *init_symbol;
908 struct symbol *fini_symbol;
909
910 /* The description of the segments in the output file as described
911 in the default linker script. This information will be used in
912 addition to the user-provided information. */
913 struct output_segment *default_output_segments;
914 /* Search paths added by the default linker script. */
915 struct pathelement *default_paths;
916
917 #ifndef BASE_ELF_NAME
918 /* The handle of the ld backend library. */
919 void *ldlib;
920 #endif
921
922 /* String table for the section headers. */
923 struct Ebl_Strtab *shstrtab;
924
925 /* True if output file should contain symbol table. */
926 bool need_symtab;
927 /* Symbol table section. */
928 Elf32_Word symscnidx;
929 /* Extended section table section. */
930 Elf32_Word xndxscnidx;
931 /* Symbol string table section. */
932 Elf32_Word strscnidx;
933
934 /* True if output file should contain dynamic symbol table. */
935 bool need_dynsym;
936 /* Dynamic symbol table section. */
937 Elf32_Word dynsymscnidx;
938 /* Dynamic symbol string table section. */
939 Elf32_Word dynstrscnidx;
940 /* Dynamic symbol hash tables. */
941 size_t hashscnidx;
942 size_t gnuhashscnidx;
943
944 /* Procedure linkage table section. */
945 Elf32_Word pltscnidx;
946 /* Number of entries already in the PLT section. */
947 size_t nplt_used;
948 /* Relocation for procedure linkage table section. */
949 Elf32_Word pltrelscnidx;
950
951 /* Global offset table section. */
952 Elf32_Word gotscnidx;
953 /* And the part of the PLT. */
954 Elf32_Word gotpltscnidx;
955
956 /* This section will hole all non-PLT relocations. */
957 Elf32_Word reldynscnidx;
958
959 /* Index of the sections to handle versioning. */
960 Elf32_Word versymscnidx;
961 Elf32_Word verneedscnidx;
962 /* XXX Should the following names be verneed...? */
963 /* Number of version definitions in input DSOs used. */
964 int nverdefused;
965 /* Number of input DSOs using versioning. */
966 int nverdeffile;
967 /* Index of next version. */
968 int nextveridx;
969
970 /* TLS segment. */
971 bool need_tls;
972 XElf_Addr tls_start;
973 XElf_Addr tls_tcb;
974
975 /* Hash table for version symbol strings. Only strings without
976 special characters are hashed here. */
977 ld_version_str_tab version_str_tab;
978 /* At most one of the following two variables is set to true if either
979 global or local symbol binding is selected as the default. */
980 bool default_bind_local;
981 bool default_bind_global;
982
983 /* Execuatable stack selection. */
984 enum execstack
985 {
986 execstack_false = 0,
987 execstack_true,
988 execstack_false_force
989 } execstack;
990
991 /* True if only used sections are used. */
992 bool gc_sections;
993
994 /* Array to determine final index of symbol. */
995 Elf32_Word *dblindirect;
996
997 /* Section group handling. */
998 struct scngroup
999 {
1000 Elf32_Word outscnidx;
1001 int nscns;
1002 struct member
1003 {
1004 struct scnhead *scn;
1005 struct member *next;
1006 } *member;
1007 struct Ebl_Strent *nameent;
1008 struct symbol *symbol;
1009 struct scngroup *next;
1010 } *groups;
1011
1012 /* True if the output file needs a .got section. */
1013 bool need_got;
1014 /* Number of relocations for GOT section caused. */
1015 size_t nrel_got;
1016
1017 /* Number of entries needed in the .dynamic section. */
1018 int ndynamic;
1019 /* To keep track of added entries. */
1020 int ndynamic_filled;
1021 /* Index for the dynamic section. */
1022 Elf32_Word dynamicscnidx;
1023
1024 /* Flags set in the DT_FLAGS word. */
1025 Elf32_Word dt_flags;
1026 /* Flags set in the DT_FLAGS_1 word. */
1027 Elf32_Word dt_flags_1;
1028 /* Flags set in the DT_FEATURE_1 word. */
1029 Elf32_Word dt_feature_1;
1030
1031 /* Lazy-loading state for dependencies. */
1032 bool lazyload;
1033
1034 /* True if an .eh_frame_hdr section should be generated. */
1035 bool eh_frame_hdr;
1036
1037 /* What hash style to generate. */
1038 enum
1039 {
1040 hash_style_none = 0,
1041 hash_style_sysv = 1,
1042 #define GENERATE_SYSV_HASH ((ld_state.hash_style & hash_style_sysv) != 0)
1043 hash_style_gnu = 2
1044 #define GENERATE_GNU_HASH ((ld_state.hash_style & hash_style_gnu) != 0)
1045 }
1046 hash_style;
1047
1048
1049 /* True if in executables all global symbols should be exported in
1050 the dynamic symbol table. */
1051 bool export_all_dynamic;
1052
1053 /* Build-ID style. NULL is none. */
1054 const char *build_id;
1055 Elf32_Word buildidscnidx;
1056
1057 /* If DSO is generated, this is the SONAME. */
1058 const char *soname;
1059
1060 /* List of all relocation sections. */
1061 struct scninfo *rellist;
1062 /* Total size of non-PLT relocations. */
1063 size_t relsize_total;
1064
1065 /* Record for the GOT symbol, if known. */
1066 struct symbol *got_symbol;
1067 /* Record for the dynamic section symbol, if known. */
1068 struct symbol *dyn_symbol;
1069
1070 /* Obstack used for small objects which will not be deleted. */
1071 struct obstack smem;
1072 };
1073
1074
1075 /* The interface to the scanner. */
1076
1077 /* Parser entry point. */
1078 extern int ldparse (void);
1079
1080 /* The input file. */
1081 extern FILE *ldin;
1082
1083 /* Name of the input file. */
1084 extern const char *ldin_fname;
1085
1086 /* Current line number. Must be reset for a new file. */
1087 extern int ldlineno;
1088
1089 /* If nonzero we are currently parsing a version script. */
1090 extern int ld_scan_version_script;
1091
1092 /* Flags defined in ld.c. */
1093 extern int verbose;
1094 extern int conserve_memory;
1095
1096
1097 /* Linker state. This contains all global information. */
1098 extern struct ld_state ld_state;
1099
1100
1101 /* Generic ld helper functions. */
1102
1103 /* Append a new directory to search libraries in. */
1104 extern void ld_new_searchdir (const char *dir);
1105
1106 /* Append a new file to the list of input files. */
1107 extern struct usedfiles *ld_new_inputfile (const char *fname,
1108 enum file_type type);
1109
1110
1111 /* These are the generic implementations for the callbacks used by ld. */
1112
1113 /* Initialize state object. This callback function is called after the
1114 parameters are parsed but before any file is searched for. */
1115 extern int ld_prepare_state (const char *emulation);
1116
1117
1118 /* Function to determine whether an object will be dynamically linked. */
1119 extern bool dynamically_linked_p (void);
1120
1121 /* Helper functions for the architecture specific code. */
1122
1123 /* Checked whether the symbol is undefined and referenced from a DSO. */
1124 extern bool linked_from_dso_p (struct scninfo *scninfo, size_t symidx);
1125 #ifdef __GNUC_STDC_INLINE__
1126 __attribute__ ((__gnu_inline__))
1127 #endif
1128 extern inline bool
linked_from_dso_p(struct scninfo * scninfo,size_t symidx)1129 linked_from_dso_p (struct scninfo *scninfo, size_t symidx)
1130 {
1131 struct usedfiles *file = scninfo->fileinfo;
1132
1133 /* If this symbol is not undefined in this file it cannot come from
1134 a DSO. */
1135 if (symidx < file->nlocalsymbols)
1136 return false;
1137
1138 struct symbol *sym = file->symref[symidx];
1139
1140 return sym->defined && sym->in_dso;
1141 }
1142
1143 #endif /* ld.h */
1144