Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* bfdlink.h -- header file for BFD link routines |
9a1b9f82 | 2 | Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002 |
4f1d9bd8 | 3 | Free Software Foundation, Inc. |
252b5132 RH |
4 | Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. |
5 | ||
e0076ab3 | 6 | This file is part of BFD, the Binary File Descriptor library. |
252b5132 | 7 | |
e0076ab3 NC |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
252b5132 | 12 | |
e0076ab3 NC |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
252b5132 | 17 | |
e0076ab3 NC |
18 | You should have received a copy of the GNU General Public License |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
252b5132 RH |
21 | |
22 | #ifndef BFDLINK_H | |
23 | #define BFDLINK_H | |
24 | ||
25 | /* Which symbols to strip during a link. */ | |
26 | enum bfd_link_strip | |
27 | { | |
28 | strip_none, /* Don't strip any symbols. */ | |
29 | strip_debugger, /* Strip debugging symbols. */ | |
30 | strip_some, /* keep_hash is the list of symbols to keep. */ | |
31 | strip_all /* Strip all symbols. */ | |
32 | }; | |
33 | ||
34 | /* Which local symbols to discard during a link. This is irrelevant | |
35 | if strip_all is used. */ | |
36 | enum bfd_link_discard | |
37 | { | |
f5fa8ca2 JJ |
38 | discard_sec_merge, /* Discard local temporary symbols in SEC_MERGE |
39 | sections. */ | |
252b5132 RH |
40 | discard_none, /* Don't discard any locals. */ |
41 | discard_l, /* Discard local temporary symbols. */ | |
42 | discard_all /* Discard all locals. */ | |
43 | }; | |
8ea2e4bd NC |
44 | |
45 | /* Describes the type of hash table entry structure being used. | |
46 | Different hash table structure have different fields and so | |
47 | support different linking features. */ | |
48 | enum bfd_link_hash_table_type | |
49 | { | |
50 | bfd_link_generic_hash_table, | |
51 | bfd_link_elf_hash_table | |
52 | }; | |
252b5132 RH |
53 | \f |
54 | /* These are the possible types of an entry in the BFD link hash | |
55 | table. */ | |
56 | ||
57 | enum bfd_link_hash_type | |
58 | { | |
59 | bfd_link_hash_new, /* Symbol is new. */ | |
60 | bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ | |
61 | bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ | |
62 | bfd_link_hash_defined, /* Symbol is defined. */ | |
63 | bfd_link_hash_defweak, /* Symbol is weak and defined. */ | |
64 | bfd_link_hash_common, /* Symbol is common. */ | |
65 | bfd_link_hash_indirect, /* Symbol is an indirect link. */ | |
66 | bfd_link_hash_warning /* Like indirect, but warn if referenced. */ | |
67 | }; | |
68 | ||
69 | /* The linking routines use a hash table which uses this structure for | |
70 | its elements. */ | |
71 | ||
72 | struct bfd_link_hash_entry | |
73 | { | |
74 | /* Base hash table entry structure. */ | |
75 | struct bfd_hash_entry root; | |
76 | /* Type of this entry. */ | |
77 | enum bfd_link_hash_type type; | |
78 | ||
79 | /* Undefined and common symbols are kept in a linked list through | |
80 | this field. This field is not in the union because that would | |
81 | force us to remove entries from the list when we changed their | |
82 | type, which would force the list to be doubly linked, which would | |
83 | waste more memory. When an undefined or common symbol is | |
84 | created, it should be added to this list, the head of which is in | |
85 | the link hash table itself. As symbols are defined, they need | |
86 | not be removed from the list; anything which reads the list must | |
87 | doublecheck the symbol type. | |
88 | ||
89 | Weak symbols are not kept on this list. | |
90 | ||
91 | Defined and defweak symbols use this field as a reference marker. | |
92 | If the field is not NULL, or this structure is the tail of the | |
93 | undefined symbol list, the symbol has been referenced. If the | |
94 | symbol is undefined and becomes defined, this field will | |
95 | automatically be non-NULL since the symbol will have been on the | |
96 | undefined symbol list. */ | |
97 | struct bfd_link_hash_entry *next; | |
98 | /* A union of information depending upon the type. */ | |
99 | union | |
100 | { | |
101 | /* Nothing is kept for bfd_hash_new. */ | |
102 | /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ | |
103 | struct | |
104 | { | |
105 | bfd *abfd; /* BFD symbol was found in. */ | |
106 | } undef; | |
107 | /* bfd_link_hash_defined, bfd_link_hash_defweak. */ | |
108 | struct | |
109 | { | |
110 | bfd_vma value; /* Symbol value. */ | |
111 | asection *section; /* Symbol section. */ | |
112 | } def; | |
113 | /* bfd_link_hash_indirect, bfd_link_hash_warning. */ | |
114 | struct | |
115 | { | |
116 | struct bfd_link_hash_entry *link; /* Real symbol. */ | |
117 | const char *warning; /* Warning (bfd_link_hash_warning only). */ | |
118 | } i; | |
119 | /* bfd_link_hash_common. */ | |
120 | struct | |
121 | { | |
122 | /* The linker needs to know three things about common | |
123 | symbols: the size, the alignment, and the section in | |
124 | which the symbol should be placed. We store the size | |
125 | here, and we allocate a small structure to hold the | |
126 | section and the alignment. The alignment is stored as a | |
127 | power of two. We don't store all the information | |
128 | directly because we don't want to increase the size of | |
129 | the union; this structure is a major space user in the | |
130 | linker. */ | |
131 | bfd_size_type size; /* Common symbol size. */ | |
132 | struct bfd_link_hash_common_entry | |
133 | { | |
134 | unsigned int alignment_power; /* Alignment. */ | |
135 | asection *section; /* Symbol section. */ | |
136 | } *p; | |
137 | } c; | |
138 | } u; | |
139 | }; | |
140 | ||
141 | /* This is the link hash table. It is a derived class of | |
142 | bfd_hash_table. */ | |
143 | ||
144 | struct bfd_link_hash_table | |
145 | { | |
146 | /* The hash table itself. */ | |
147 | struct bfd_hash_table table; | |
148 | /* The back end which created this hash table. This indicates the | |
149 | type of the entries in the hash table, which is sometimes | |
150 | important information when linking object files of different | |
151 | types together. */ | |
152 | const bfd_target *creator; | |
153 | /* A linked list of undefined and common symbols, linked through the | |
154 | next field in the bfd_link_hash_entry structure. */ | |
155 | struct bfd_link_hash_entry *undefs; | |
156 | /* Entries are added to the tail of the undefs list. */ | |
157 | struct bfd_link_hash_entry *undefs_tail; | |
8ea2e4bd NC |
158 | /* The type of the ink hash table. */ |
159 | enum bfd_link_hash_table_type type; | |
252b5132 RH |
160 | }; |
161 | ||
162 | /* Look up an entry in a link hash table. If FOLLOW is true, this | |
163 | follows bfd_link_hash_indirect and bfd_link_hash_warning links to | |
164 | the real symbol. */ | |
165 | extern struct bfd_link_hash_entry *bfd_link_hash_lookup | |
166 | PARAMS ((struct bfd_link_hash_table *, const char *, boolean create, | |
167 | boolean copy, boolean follow)); | |
168 | ||
169 | /* Look up an entry in the main linker hash table if the symbol might | |
170 | be wrapped. This should only be used for references to an | |
171 | undefined symbol, not for definitions of a symbol. */ | |
172 | ||
173 | extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup | |
174 | PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean, | |
175 | boolean)); | |
176 | ||
177 | /* Traverse a link hash table. */ | |
178 | extern void bfd_link_hash_traverse | |
179 | PARAMS ((struct bfd_link_hash_table *, | |
180 | boolean (*) (struct bfd_link_hash_entry *, PTR), | |
181 | PTR)); | |
182 | ||
183 | /* Add an entry to the undefs list. */ | |
184 | extern void bfd_link_add_undef | |
185 | PARAMS ((struct bfd_link_hash_table *, struct bfd_link_hash_entry *)); | |
7815cf4f AM |
186 | |
187 | struct bfd_sym_chain | |
188 | { | |
189 | struct bfd_sym_chain *next; | |
190 | const char *name; | |
191 | }; | |
252b5132 RH |
192 | \f |
193 | /* This structure holds all the information needed to communicate | |
194 | between BFD and the linker when doing a link. */ | |
195 | ||
196 | struct bfd_link_info | |
197 | { | |
198 | /* Function callbacks. */ | |
199 | const struct bfd_link_callbacks *callbacks; | |
7815cf4f | 200 | |
252b5132 RH |
201 | /* true if BFD should generate a relocateable object file. */ |
202 | boolean relocateable; | |
7815cf4f AM |
203 | |
204 | /* true if BFD should generate relocation information in the final | |
205 | executable. */ | |
a712da20 | 206 | boolean emitrelocations; |
7815cf4f | 207 | |
252b5132 | 208 | /* true if BFD should generate a "task linked" object file, |
7815cf4f AM |
209 | similar to relocatable but also with globals converted to |
210 | statics. */ | |
252b5132 | 211 | boolean task_link; |
7815cf4f | 212 | |
252b5132 RH |
213 | /* true if BFD should generate a shared object. */ |
214 | boolean shared; | |
7815cf4f | 215 | |
252b5132 RH |
216 | /* true if BFD should pre-bind symbols in a shared object. */ |
217 | boolean symbolic; | |
7815cf4f | 218 | |
7be4069c HPN |
219 | /* true if BFD should export all symbols in the dynamic symbol table |
220 | of an executable, rather than only those used. */ | |
221 | boolean export_dynamic; | |
7815cf4f | 222 | |
252b5132 RH |
223 | /* true if shared objects should be linked directly, not shared. */ |
224 | boolean static_link; | |
7815cf4f | 225 | |
252b5132 RH |
226 | /* true if the output file should be in a traditional format. This |
227 | is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag | |
228 | on the output file, but may be checked when reading the input | |
229 | files. */ | |
230 | boolean traditional_format; | |
7815cf4f | 231 | |
252b5132 RH |
232 | /* true if we want to produced optimized output files. This might |
233 | need much more time and therefore must be explicitly selected. */ | |
234 | boolean optimize; | |
7815cf4f | 235 | |
252b5132 RH |
236 | /* true if BFD should generate errors for undefined symbols |
237 | even if generating a shared object. */ | |
238 | boolean no_undefined; | |
7815cf4f | 239 | |
b79e8c78 NC |
240 | /* true if BFD should allow undefined symbols in shared objects even |
241 | when no_undefined is set to disallow undefined symbols. The net | |
242 | result will be that undefined symbols in regular objects will | |
243 | still trigger an error, but undefined symbols in shared objects | |
244 | will be ignored. The implementation of no_undefined makes the | |
245 | assumption that the runtime linker will choke on undefined | |
246 | symbols. However there is at least one system (BeOS) where | |
247 | undefined symbols in shared libraries is normal since the kernel | |
248 | patches them at load time to select which function is most | |
249 | appropriate for the current architecture. I.E. dynamically | |
250 | select an appropriate memset function. Apparently it is also | |
251 | normal for HPPA shared libraries to have undefined symbols. */ | |
252 | boolean allow_shlib_undefined; | |
7815cf4f AM |
253 | |
254 | /* true if ok to have multiple definition. */ | |
6713542f | 255 | boolean allow_multiple_definition; |
7815cf4f | 256 | |
252b5132 RH |
257 | /* Which symbols to strip. */ |
258 | enum bfd_link_strip strip; | |
7815cf4f | 259 | |
252b5132 RH |
260 | /* Which local symbols to discard. */ |
261 | enum bfd_link_discard discard; | |
7815cf4f | 262 | |
252b5132 RH |
263 | /* true if symbols should be retained in memory, false if they |
264 | should be freed and reread. */ | |
265 | boolean keep_memory; | |
7815cf4f | 266 | |
252b5132 RH |
267 | /* The list of input BFD's involved in the link. These are chained |
268 | together via the link_next field. */ | |
269 | bfd *input_bfds; | |
7815cf4f | 270 | |
252b5132 RH |
271 | /* If a symbol should be created for each input BFD, this is section |
272 | where those symbols should be placed. It must be a section in | |
273 | the output BFD. It may be NULL, in which case no such symbols | |
274 | will be created. This is to support CREATE_OBJECT_SYMBOLS in the | |
275 | linker command language. */ | |
276 | asection *create_object_symbols_section; | |
7815cf4f AM |
277 | |
278 | /* List of global symbol names that are starting points for marking | |
279 | sections against garbage collection. */ | |
280 | struct bfd_sym_chain *gc_sym_list; | |
281 | ||
252b5132 RH |
282 | /* Hash table handled by BFD. */ |
283 | struct bfd_link_hash_table *hash; | |
7815cf4f | 284 | |
252b5132 RH |
285 | /* Hash table of symbols to keep. This is NULL unless strip is |
286 | strip_some. */ | |
287 | struct bfd_hash_table *keep_hash; | |
7815cf4f | 288 | |
252b5132 RH |
289 | /* true if every symbol should be reported back via the notice |
290 | callback. */ | |
291 | boolean notice_all; | |
7815cf4f | 292 | |
252b5132 RH |
293 | /* Hash table of symbols to report back via the notice callback. If |
294 | this is NULL, and notice_all is false, then no symbols are | |
295 | reported back. */ | |
296 | struct bfd_hash_table *notice_hash; | |
7815cf4f | 297 | |
252b5132 RH |
298 | /* Hash table of symbols which are being wrapped (the --wrap linker |
299 | option). If this is NULL, no symbols are being wrapped. */ | |
300 | struct bfd_hash_table *wrap_hash; | |
7815cf4f | 301 | |
252b5132 RH |
302 | /* If a base output file is wanted, then this points to it */ |
303 | PTR base_file; | |
304 | ||
305 | /* If non-zero, specifies that branches which are problematic for the | |
306 | MPC860 C0 (or earlier) should be checked for and modified. It gives the | |
307 | number of bytes that should be checked at the end of each text page. */ | |
308 | int mpc860c0; | |
94883c63 MM |
309 | |
310 | /* The function to call when the executable or shared object is | |
311 | loaded. */ | |
312 | const char *init_function; | |
7815cf4f | 313 | |
94883c63 MM |
314 | /* The function to call when the executable or shared object is |
315 | unloaded. */ | |
316 | const char *fini_function; | |
9bfcb6d6 | 317 | |
eec8c321 L |
318 | /* true if the new ELF dynamic tags are enabled. */ |
319 | boolean new_dtags; | |
320 | ||
9bfcb6d6 L |
321 | /* May be used to set DT_FLAGS for ELF. */ |
322 | bfd_vma flags; | |
323 | ||
324 | /* May be used to set DT_FLAGS_1 for ELF. */ | |
325 | bfd_vma flags_1; | |
3ede731b | 326 | |
e0076ab3 NC |
327 | /* Non-zero if auto-import thunks for DATA items in pei386 DLLs |
328 | should be generated/linked against. Set to 1 if this feature | |
329 | is explicitly requested by the user, -1 if enabled by default. */ | |
330 | int pei386_auto_import; | |
db6751f2 JJ |
331 | |
332 | /* True if non-PLT relocs should be merged into one reloc section | |
333 | and sorted so that relocs against the same symbol come together. */ | |
334 | boolean combreloc; | |
335 | ||
8bd621d8 AM |
336 | /* True if executable should not contain copy relocs. |
337 | Setting this true may result in a non-sharable text segment. */ | |
338 | boolean nocopyreloc; | |
339 | ||
65765700 JJ |
340 | /* True if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment |
341 | should be created. */ | |
342 | boolean eh_frame_hdr; | |
343 | ||
db6751f2 | 344 | /* How many spare .dynamic DT_NULL entries should be added? */ |
b7781dbe | 345 | unsigned int spare_dynamic_tags; |
252b5132 RH |
346 | }; |
347 | ||
348 | /* This structures holds a set of callback functions. These are | |
349 | called by the BFD linker routines. The first argument to each | |
350 | callback function is the bfd_link_info structure being used. Each | |
351 | function returns a boolean value. If the function returns false, | |
352 | then the BFD function which called it will return with a failure | |
353 | indication. */ | |
354 | ||
355 | struct bfd_link_callbacks | |
356 | { | |
357 | /* A function which is called when an object is added from an | |
358 | archive. ABFD is the archive element being added. NAME is the | |
359 | name of the symbol which caused the archive element to be pulled | |
360 | in. */ | |
361 | boolean (*add_archive_element) PARAMS ((struct bfd_link_info *, | |
362 | bfd *abfd, | |
363 | const char *name)); | |
364 | /* A function which is called when a symbol is found with multiple | |
365 | definitions. NAME is the symbol which is defined multiple times. | |
366 | OBFD is the old BFD, OSEC is the old section, OVAL is the old | |
367 | value, NBFD is the new BFD, NSEC is the new section, and NVAL is | |
368 | the new value. OBFD may be NULL. OSEC and NSEC may be | |
369 | bfd_com_section or bfd_ind_section. */ | |
370 | boolean (*multiple_definition) PARAMS ((struct bfd_link_info *, | |
371 | const char *name, | |
372 | bfd *obfd, | |
373 | asection *osec, | |
374 | bfd_vma oval, | |
375 | bfd *nbfd, | |
376 | asection *nsec, | |
377 | bfd_vma nval)); | |
378 | /* A function which is called when a common symbol is defined | |
379 | multiple times. NAME is the symbol appearing multiple times. | |
380 | OBFD is the BFD of the existing symbol; it may be NULL if this is | |
381 | not known. OTYPE is the type of the existing symbol, which may | |
382 | be bfd_link_hash_defined, bfd_link_hash_defweak, | |
383 | bfd_link_hash_common, or bfd_link_hash_indirect. If OTYPE is | |
384 | bfd_link_hash_common, OSIZE is the size of the existing symbol. | |
385 | NBFD is the BFD of the new symbol. NTYPE is the type of the new | |
386 | symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or | |
387 | bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE | |
388 | is the size of the new symbol. */ | |
389 | boolean (*multiple_common) PARAMS ((struct bfd_link_info *, | |
390 | const char *name, | |
391 | bfd *obfd, | |
392 | enum bfd_link_hash_type otype, | |
393 | bfd_vma osize, | |
394 | bfd *nbfd, | |
395 | enum bfd_link_hash_type ntype, | |
396 | bfd_vma nsize)); | |
397 | /* A function which is called to add a symbol to a set. ENTRY is | |
398 | the link hash table entry for the set itself (e.g., | |
399 | __CTOR_LIST__). RELOC is the relocation to use for an entry in | |
400 | the set when generating a relocateable file, and is also used to | |
401 | get the size of the entry when generating an executable file. | |
402 | ABFD, SEC and VALUE identify the value to add to the set. */ | |
403 | boolean (*add_to_set) PARAMS ((struct bfd_link_info *, | |
404 | struct bfd_link_hash_entry *entry, | |
405 | bfd_reloc_code_real_type reloc, | |
406 | bfd *abfd, asection *sec, bfd_vma value)); | |
407 | /* A function which is called when the name of a g++ constructor or | |
408 | destructor is found. This is only called by some object file | |
409 | formats. CONSTRUCTOR is true for a constructor, false for a | |
410 | destructor. This will use BFD_RELOC_CTOR when generating a | |
411 | relocateable file. NAME is the name of the symbol found. ABFD, | |
412 | SECTION and VALUE are the value of the symbol. */ | |
413 | boolean (*constructor) PARAMS ((struct bfd_link_info *, | |
414 | boolean constructor, | |
415 | const char *name, bfd *abfd, asection *sec, | |
416 | bfd_vma value)); | |
417 | /* A function which is called to issue a linker warning. For | |
418 | example, this is called when there is a reference to a warning | |
419 | symbol. WARNING is the warning to be issued. SYMBOL is the name | |
420 | of the symbol which triggered the warning; it may be NULL if | |
421 | there is none. ABFD, SECTION and ADDRESS identify the location | |
422 | which trigerred the warning; either ABFD or SECTION or both may | |
423 | be NULL if the location is not known. */ | |
424 | boolean (*warning) PARAMS ((struct bfd_link_info *, | |
425 | const char *warning, const char *symbol, | |
426 | bfd *abfd, asection *section, | |
427 | bfd_vma address)); | |
428 | /* A function which is called when a relocation is attempted against | |
429 | an undefined symbol. NAME is the symbol which is undefined. | |
430 | ABFD, SECTION and ADDRESS identify the location from which the | |
c086cbc6 L |
431 | reference is made. FATAL indicates whether an undefined symbol is |
432 | a fatal error or not. In some cases SECTION may be NULL. */ | |
252b5132 RH |
433 | boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *, |
434 | const char *name, bfd *abfd, | |
c086cbc6 L |
435 | asection *section, |
436 | bfd_vma address, | |
437 | boolean fatal)); | |
252b5132 RH |
438 | /* A function which is called when a reloc overflow occurs. NAME is |
439 | the name of the symbol or section the reloc is against, | |
440 | RELOC_NAME is the name of the relocation, and ADDEND is any | |
441 | addend that is used. ABFD, SECTION and ADDRESS identify the | |
442 | location at which the overflow occurs; if this is the result of a | |
443 | bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then | |
444 | ABFD will be NULL. */ | |
445 | boolean (*reloc_overflow) PARAMS ((struct bfd_link_info *, | |
446 | const char *name, | |
447 | const char *reloc_name, bfd_vma addend, | |
448 | bfd *abfd, asection *section, | |
449 | bfd_vma address)); | |
450 | /* A function which is called when a dangerous reloc is performed. | |
451 | The canonical example is an a29k IHCONST reloc which does not | |
452 | follow an IHIHALF reloc. MESSAGE is an appropriate message. | |
453 | ABFD, SECTION and ADDRESS identify the location at which the | |
454 | problem occurred; if this is the result of a | |
455 | bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then | |
456 | ABFD will be NULL. */ | |
457 | boolean (*reloc_dangerous) PARAMS ((struct bfd_link_info *, | |
458 | const char *message, | |
459 | bfd *abfd, asection *section, | |
460 | bfd_vma address)); | |
461 | /* A function which is called when a reloc is found to be attached | |
462 | to a symbol which is not being written out. NAME is the name of | |
463 | the symbol. ABFD, SECTION and ADDRESS identify the location of | |
464 | the reloc; if this is the result of a | |
465 | bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then | |
466 | ABFD will be NULL. */ | |
467 | boolean (*unattached_reloc) PARAMS ((struct bfd_link_info *, | |
468 | const char *name, | |
469 | bfd *abfd, asection *section, | |
470 | bfd_vma address)); | |
471 | /* A function which is called when a symbol in notice_hash is | |
472 | defined or referenced. NAME is the symbol. ABFD, SECTION and | |
473 | ADDRESS are the value of the symbol. If SECTION is | |
474 | bfd_und_section, this is a reference. */ | |
475 | boolean (*notice) PARAMS ((struct bfd_link_info *, const char *name, | |
476 | bfd *abfd, asection *section, bfd_vma address)); | |
477 | }; | |
478 | \f | |
479 | /* The linker builds link_order structures which tell the code how to | |
480 | include input data in the output file. */ | |
481 | ||
482 | /* These are the types of link_order structures. */ | |
483 | ||
484 | enum bfd_link_order_type | |
485 | { | |
486 | bfd_undefined_link_order, /* Undefined. */ | |
487 | bfd_indirect_link_order, /* Built from a section. */ | |
252b5132 RH |
488 | bfd_data_link_order, /* Set to explicit data. */ |
489 | bfd_section_reloc_link_order, /* Relocate against a section. */ | |
490 | bfd_symbol_reloc_link_order /* Relocate against a symbol. */ | |
491 | }; | |
492 | ||
493 | /* This is the link_order structure itself. These form a chain | |
494 | attached to the section whose contents they are describing. */ | |
495 | ||
496 | struct bfd_link_order | |
497 | { | |
498 | /* Next link_order in chain. */ | |
499 | struct bfd_link_order *next; | |
500 | /* Type of link_order. */ | |
501 | enum bfd_link_order_type type; | |
502 | /* Offset within output section. */ | |
503 | bfd_vma offset; | |
504 | /* Size within output section. */ | |
505 | bfd_size_type size; | |
506 | /* Type specific information. */ | |
507 | union | |
508 | { | |
509 | struct | |
510 | { | |
511 | /* Section to include. If this is used, then | |
512 | section->output_section must be the section the | |
513 | link_order is attached to, section->output_offset must | |
514 | equal the link_order offset field, and section->_raw_size | |
515 | must equal the link_order size field. Maybe these | |
516 | restrictions should be relaxed someday. */ | |
517 | asection *section; | |
518 | } indirect; | |
519 | struct | |
520 | { | |
9a1b9f82 AM |
521 | /* Size of contents, or zero when contents size == size |
522 | within output section. | |
523 | A non-zero value allows filling of the output section | |
524 | with an arbitrary repeated pattern. */ | |
525 | unsigned int size; | |
526 | /* Data to put into file. */ | |
252b5132 RH |
527 | bfd_byte *contents; |
528 | } data; | |
529 | struct | |
530 | { | |
531 | /* Description of reloc to generate. Used for | |
532 | bfd_section_reloc_link_order and | |
533 | bfd_symbol_reloc_link_order. */ | |
534 | struct bfd_link_order_reloc *p; | |
535 | } reloc; | |
536 | } u; | |
537 | }; | |
538 | ||
539 | /* A linker order of type bfd_section_reloc_link_order or | |
540 | bfd_symbol_reloc_link_order means to create a reloc against a | |
541 | section or symbol, respectively. This is used to implement -Ur to | |
542 | generate relocs for the constructor tables. The | |
543 | bfd_link_order_reloc structure describes the reloc that BFD should | |
544 | create. It is similar to a arelent, but I didn't use arelent | |
545 | because the linker does not know anything about most symbols, and | |
546 | any asymbol structure it creates will be partially meaningless. | |
547 | This information could logically be in the bfd_link_order struct, | |
548 | but I didn't want to waste the space since these types of relocs | |
549 | are relatively rare. */ | |
550 | ||
551 | struct bfd_link_order_reloc | |
552 | { | |
553 | /* Reloc type. */ | |
554 | bfd_reloc_code_real_type reloc; | |
555 | ||
556 | union | |
557 | { | |
558 | /* For type bfd_section_reloc_link_order, this is the section | |
559 | the reloc should be against. This must be a section in the | |
560 | output BFD, not any of the input BFDs. */ | |
561 | asection *section; | |
562 | /* For type bfd_symbol_reloc_link_order, this is the name of the | |
563 | symbol the reloc should be against. */ | |
564 | const char *name; | |
565 | } u; | |
566 | ||
567 | /* Addend to use. The object file should contain zero. The BFD | |
568 | backend is responsible for filling in the contents of the object | |
569 | file correctly. For some object file formats (e.g., COFF) the | |
570 | addend must be stored into in the object file, and for some | |
571 | (e.g., SPARC a.out) it is kept in the reloc. */ | |
572 | bfd_vma addend; | |
573 | }; | |
574 | ||
575 | /* Allocate a new link_order for a section. */ | |
576 | extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *)); | |
577 | ||
578 | /* These structures are used to describe version information for the | |
579 | ELF linker. These structures could be manipulated entirely inside | |
580 | BFD, but it would be a pain. Instead, the regular linker sets up | |
581 | these structures, and then passes them into BFD. */ | |
582 | ||
583 | /* Regular expressions for a version. */ | |
584 | ||
585 | struct bfd_elf_version_expr | |
586 | { | |
587 | /* Next regular expression for this version. */ | |
588 | struct bfd_elf_version_expr *next; | |
589 | /* Regular expression. */ | |
590 | const char *pattern; | |
591 | /* Matching function. */ | |
592 | int (*match) PARAMS((struct bfd_elf_version_expr *, const char *)); | |
593 | }; | |
594 | ||
595 | /* Version dependencies. */ | |
596 | ||
597 | struct bfd_elf_version_deps | |
598 | { | |
599 | /* Next dependency for this version. */ | |
600 | struct bfd_elf_version_deps *next; | |
601 | /* The version which this version depends upon. */ | |
602 | struct bfd_elf_version_tree *version_needed; | |
603 | }; | |
604 | ||
605 | /* A node in the version tree. */ | |
606 | ||
607 | struct bfd_elf_version_tree | |
608 | { | |
609 | /* Next version. */ | |
610 | struct bfd_elf_version_tree *next; | |
611 | /* Name of this version. */ | |
612 | const char *name; | |
613 | /* Version number. */ | |
614 | unsigned int vernum; | |
615 | /* Regular expressions for global symbols in this version. */ | |
616 | struct bfd_elf_version_expr *globals; | |
617 | /* Regular expressions for local symbols in this version. */ | |
618 | struct bfd_elf_version_expr *locals; | |
619 | /* List of versions which this version depends upon. */ | |
620 | struct bfd_elf_version_deps *deps; | |
621 | /* Index of the version name. This is used within BFD. */ | |
622 | unsigned int name_indx; | |
623 | /* Whether this version tree was used. This is used within BFD. */ | |
624 | int used; | |
625 | }; | |
626 | ||
627 | #endif |