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