1 /* LTO plugin for gold and/or GNU ld.
2 Copyright (C) 2009, 2010 Free Software Foundation, Inc.
3 Contributed by Rafael Avila de Espindola (espindola@google.com).
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3, or (at your option)
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
19 /* The plugin has only one external function: onload. Gold passes it an array of
20 function that the plugin uses to communicate back to gold.
22 With the functions provided by gold, the plugin can be notified when
23 gold first analyzes a file and pass a symbol table back to gold. The plugin
24 is also notified when all symbols have been read and it is time to generate
25 machine code for the necessary symbols.
27 More information at http://gcc.gnu.org/wiki/whopr/driver.
29 This plugin should be passed the lto-wrapper options and will forward them.
30 It also has 2 options of its own:
31 -debug: Print the command line used to run lto-wrapper.
32 -nop: Instead of running lto-wrapper, pass the original to the plugin. This
33 only works if the input files are hybrid. */
49 #include <sys/types.h>
50 #ifdef HAVE_SYS_WAIT_H
54 #define WIFEXITED(S) (((S) & 0xff) == 0)
57 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
59 #include <libiberty.h>
61 #include "../gcc/lto/common.h"
62 #include "simple-object.h"
63 #include "plugin-api.h"
65 /* Handle opening elf files on hosts, such as Windows, that may use
66 text file handling that will break binary access. */
71 /* Segment name for LTO sections. This is only used for Mach-O.
72 FIXME: This needs to be kept in sync with darwin.c. */
74 #define LTO_SEGMENT_NAME "__GNU_LTO"
76 /* LTO magic section name. */
78 #define LTO_SECTION_PREFIX ".gnu.lto_.symtab"
79 #define LTO_SECTION_PREFIX_LEN (sizeof (LTO_SECTION_PREFIX) - 1)
81 /* The part of the symbol table the plugin has to keep track of. Note that we
82 must keep SYMS until all_symbols_read is called to give the linker time to
83 copy the symbol information. */
89 unsigned next_conflict
;
96 struct ld_plugin_symbol
*syms
;
100 /* Encapsulates object file data during symbol scan. */
101 struct plugin_objfile
104 simple_object_read
*objfile
;
105 struct plugin_symtab
*out
;
106 const struct ld_plugin_input_file
*file
;
109 /* All that we have to remember about a file. */
111 struct plugin_file_info
115 struct plugin_symtab symtab
;
116 struct plugin_symtab conflicts
;
119 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
120 stdio file streams, we do simple label translation here. */
124 ss_none
, /* No underscore prefix. */
125 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
126 ss_uscore
, /* Underscore prefix all symbols. */
129 static char *arguments_file_name
;
130 static ld_plugin_register_claim_file register_claim_file
;
131 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
132 static ld_plugin_get_symbols get_symbols
;
133 static ld_plugin_register_cleanup register_cleanup
;
134 static ld_plugin_add_input_file add_input_file
;
135 static ld_plugin_add_input_library add_input_library
;
136 static ld_plugin_message message
;
137 static ld_plugin_add_symbols add_symbols
;
139 static struct plugin_file_info
*claimed_files
= NULL
;
140 static unsigned int num_claimed_files
= 0;
142 static char **output_files
= NULL
;
143 static unsigned int num_output_files
= 0;
145 static char **lto_wrapper_argv
;
146 static int lto_wrapper_num_args
;
148 static char **pass_through_items
= NULL
;
149 static unsigned int num_pass_through_items
;
153 static char *resolution_file
= NULL
;
155 /* Set by default from configure.ac, but can be overridden at runtime
156 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
157 (in fact, only first letter of style arg is checked.) */
158 static enum symbol_style sym_style
= SYM_STYLE
;
161 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
167 message (level
, text
);
170 /* If there is no nicer way to inform the user, fallback to stderr. */
171 fprintf (stderr
, "%s\n", text
);
172 if (level
== LDPL_FATAL
)
177 /* This little wrapper allows check to be called with a non-integer
178 first argument, such as a pointer that must be non-NULL. We can't
179 use c99 bool type to coerce it into range, so we explicitly test. */
180 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
182 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
183 by P and the result is written in ENTRY. The slot number is stored in SLOT.
184 Returns the address of the next entry. */
187 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
191 enum ld_plugin_symbol_kind translate_kind
[] =
200 enum ld_plugin_symbol_visibility translate_visibility
[] =
213 /* cf. Duff's device. */
215 entry
->name
= xstrdup (p
);
220 entry
->name
= concat ("_", p
, NULL
);
223 check (0, LDPL_FATAL
, "invalid symbol style requested");
230 entry
->version
= NULL
;
232 entry
->comdat_key
= p
;
237 if (strlen (entry
->comdat_key
) == 0)
238 entry
->comdat_key
= NULL
;
240 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
243 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
244 entry
->def
= translate_kind
[t
];
248 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
249 entry
->visibility
= translate_visibility
[t
];
252 entry
->size
= *(uint64_t *) p
;
255 aux
->slot
= *(uint32_t *) p
;
258 entry
->resolution
= LDPR_UNKNOWN
;
260 aux
->next_conflict
= -1;
265 /* Translate the IL symbol table located between DATA and END. Append the
266 slots and symbols to OUT. */
269 translate (char *data
, char *end
, struct plugin_symtab
*out
)
272 struct ld_plugin_symbol
*syms
= NULL
;
275 /* This overestimates the output buffer sizes, but at least
276 the algorithm is O(1) now. */
278 len
= (end
- data
)/8 + out
->nsyms
+ 1;
279 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
280 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
282 for (n
= out
->nsyms
; data
< end
; n
++)
285 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
295 /* Free all memory that is no longer needed after writing the symbol
302 for (i
= 0; i
< num_claimed_files
; i
++)
304 struct plugin_file_info
*info
= &claimed_files
[i
];
305 struct plugin_symtab
*symtab
= &info
->symtab
;
307 for (j
= 0; j
< symtab
->nsyms
; j
++)
309 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
312 free (s
->comdat_key
);
319 /* Free all remaining memory. */
325 for (i
= 0; i
< num_claimed_files
; i
++)
327 struct plugin_file_info
*info
= &claimed_files
[i
];
328 struct plugin_symtab
*symtab
= &info
->symtab
;
333 for (i
= 0; i
< num_output_files
; i
++)
334 free (output_files
[i
]);
337 free (claimed_files
);
338 claimed_files
= NULL
;
339 num_claimed_files
= 0;
341 if (arguments_file_name
)
342 free (arguments_file_name
);
343 arguments_file_name
= NULL
;
346 /* Dump SYMTAB to resolution file F. */
349 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
353 for (j
= 0; j
< symtab
->nsyms
; j
++)
355 uint32_t slot
= symtab
->aux
[j
].slot
;
356 unsigned int resolution
= symtab
->syms
[j
].resolution
;
358 assert (resolution
!= LDPR_UNKNOWN
);
360 fprintf (f
, "%u %x %s %s\n", (unsigned int) slot
, symtab
->aux
[j
].id
,
361 lto_resolution_str
[resolution
],
362 symtab
->syms
[j
].name
);
366 /* Finish the conflicts' resolution information after the linker resolved
367 the original symbols */
370 finish_conflict_resolution (struct plugin_symtab
*symtab
,
371 struct plugin_symtab
*conflicts
)
375 if (conflicts
->nsyms
== 0)
378 for (i
= 0; i
< symtab
->nsyms
; i
++)
380 int resolution
= LDPR_UNKNOWN
;
382 if (symtab
->aux
[i
].next_conflict
== -1)
385 switch (symtab
->syms
[i
].def
)
388 case LDPK_COMMON
: /* ??? */
389 resolution
= LDPR_RESOLVED_IR
;
392 resolution
= LDPR_PREEMPTED_IR
;
396 resolution
= symtab
->syms
[i
].resolution
;
402 assert (resolution
!= LDPR_UNKNOWN
);
404 for (j
= symtab
->aux
[i
].next_conflict
;
406 j
= conflicts
->aux
[j
].next_conflict
)
407 conflicts
->syms
[j
].resolution
= resolution
;
411 /* Free symbol table SYMTAB. */
414 free_symtab (struct plugin_symtab
*symtab
)
422 /* Writes the relocations to disk. */
425 write_resolution (void)
430 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
431 f
= fopen (resolution_file
, "w");
432 check (f
, LDPL_FATAL
, "could not open file");
434 fprintf (f
, "%d\n", num_claimed_files
);
436 for (i
= 0; i
< num_claimed_files
; i
++)
438 struct plugin_file_info
*info
= &claimed_files
[i
];
439 struct plugin_symtab
*symtab
= &info
->symtab
;
440 struct ld_plugin_symbol
*syms
= symtab
->syms
;
442 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
444 finish_conflict_resolution (symtab
, &info
->conflicts
);
446 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
447 dump_symtab (f
, symtab
);
448 if (info
->conflicts
.nsyms
)
450 dump_symtab (f
, &info
->conflicts
);
451 free_symtab (&info
->conflicts
);
457 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
461 add_output_files (FILE *f
)
465 const unsigned piece
= 32;
466 char *buf
, *s
= xmalloc (piece
);
471 if (!fgets (buf
, piece
, f
))
477 if (s
[len
- 1] != '\n')
479 s
= xrealloc (s
, len
+ piece
);
487 = xrealloc (output_files
, num_output_files
* sizeof (char *));
488 output_files
[num_output_files
- 1] = s
;
489 add_input_file (output_files
[num_output_files
- 1]);
493 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
497 exec_lto_wrapper (char *argv
[])
503 FILE *wrapper_output
;
508 /* Write argv to a file to avoid a command line that is too long. */
509 arguments_file_name
= make_temp_file ("");
510 check (arguments_file_name
, LDPL_FATAL
,
511 "Failed to generate a temorary file name");
513 args
= fopen (arguments_file_name
, "w");
514 check (args
, LDPL_FATAL
, "could not open arguments file");
516 t
= writeargv (&argv
[1], args
);
517 check (t
== 0, LDPL_FATAL
, "could not write arguments");
519 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
521 at_args
= concat ("@", arguments_file_name
, NULL
);
522 check (at_args
, LDPL_FATAL
, "could not allocate");
524 for (i
= 1; argv
[i
]; i
++)
527 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
529 for (i
= 0; argv
[i
]; i
++)
530 fprintf (stderr
, "%s ", argv
[i
]);
531 fprintf (stderr
, "\n");
536 new_argv
[0] = argv
[0];
537 new_argv
[1] = at_args
;
542 for (i
= 0; new_argv
[i
]; i
++)
543 fprintf (stderr
, "%s ", new_argv
[i
]);
544 fprintf (stderr
, "\n");
548 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
549 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
551 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
552 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
553 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
555 wrapper_output
= pex_read_output (pex
, 0);
556 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
558 add_output_files (wrapper_output
);
560 t
= pex_get_status (pex
, 1, &status
);
561 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
562 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
563 "lto-wrapper failed");
570 /* Pass the original files back to the linker. */
573 use_original_files (void)
576 for (i
= 0; i
< num_claimed_files
; i
++)
578 struct plugin_file_info
*info
= &claimed_files
[i
];
579 add_input_file (info
->name
);
584 /* Called by the linker once all symbols have been read. */
586 static enum ld_plugin_status
587 all_symbols_read_handler (void)
590 unsigned num_lto_args
= num_claimed_files
+ lto_wrapper_num_args
+ 1;
592 const char **lto_arg_ptr
;
593 if (num_claimed_files
== 0)
598 use_original_files ();
602 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
603 lto_arg_ptr
= (const char **) lto_argv
;
604 assert (lto_wrapper_argv
);
610 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
611 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
613 for (i
= 0; i
< num_claimed_files
; i
++)
615 struct plugin_file_info
*info
= &claimed_files
[i
];
617 *lto_arg_ptr
++ = info
->name
;
620 *lto_arg_ptr
++ = NULL
;
621 exec_lto_wrapper (lto_argv
);
625 if (pass_through_items
)
628 for (i
= 0; i
< num_pass_through_items
; i
++)
630 if (strncmp (pass_through_items
[i
], "-l", 2) == 0)
631 add_input_library (pass_through_items
[i
] + 2);
633 add_input_file (pass_through_items
[i
]);
634 free (pass_through_items
[i
]);
635 pass_through_items
[i
] = NULL
;
637 free (pass_through_items
);
638 pass_through_items
= NULL
;
644 /* Remove temporary files at the end of the link. */
646 static enum ld_plugin_status
647 cleanup_handler (void)
655 if (arguments_file_name
)
657 t
= unlink (arguments_file_name
);
658 check (t
== 0, LDPL_FATAL
, "could not unlink arguments file");
661 for (i
= 0; i
< num_output_files
; i
++)
663 t
= unlink (output_files
[i
]);
664 check (t
== 0, LDPL_FATAL
, "could not unlink output file");
671 #define SWAP(type, a, b) \
672 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
674 /* Compare two hash table entries */
676 static int eq_sym (const void *a
, const void *b
)
678 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
679 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
681 return !strcmp (as
->name
, bs
->name
);
686 static hashval_t
hash_sym (const void *a
)
688 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
690 return htab_hash_string (as
->name
);
693 /* Determine how strong a symbol is */
695 static int symbol_strength (struct ld_plugin_symbol
*s
)
709 /* In the ld -r case we can get dups in the LTO symbol tables, where
710 the same symbol can have different resolutions (e.g. undefined and defined).
712 We have to keep that in the LTO symbol tables, but the dups confuse
713 gold and then finally gcc by supplying incorrect resolutions.
715 Problem is that the main gold symbol table doesn't know about subids
716 and does not distingush the same symbols in different states.
718 So we drop duplicates from the linker visible symbol table
719 and keep them in a private table. Then later do own symbol
720 resolution for the duplicated based on the results for the
723 Then when writing out the resolution file readd the dropped symbols.
725 XXX how to handle common? */
728 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
730 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
736 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
737 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
739 /* Move all duplicate symbols into the auxillary conflicts table. */
741 for (i
= 0; i
< t
->nsyms
; i
++)
743 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
744 struct sym_aux
*aux
= &t
->aux
[i
];
747 slot
= htab_find_slot (symtab
, s
, INSERT
);
751 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
752 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
754 /* Always let the linker resolve the strongest symbol */
755 if (symbol_strength (orig
) < symbol_strength (s
))
757 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
758 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
759 SWAP (unsigned, orig_aux
->id
, aux
->id
);
760 /* Don't swap conflict chain pointer */
763 /* Move current symbol into the conflicts table */
764 cnf
= conflicts
->nsyms
++;
765 conflicts
->syms
[cnf
] = *s
;
766 conflicts
->aux
[cnf
] = *aux
;
767 aux
= &conflicts
->aux
[cnf
];
769 /* Update conflicts chain of the original symbol */
770 aux
->next_conflict
= orig_aux
->next_conflict
;
771 orig_aux
->next_conflict
= cnf
;
776 /* Remove previous duplicates in the main table */
783 /* Put original into the hash table */
784 *slot
= &t
->syms
[out
];
788 assert (conflicts
->nsyms
<= outlen
);
789 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
792 htab_delete (symtab
);
795 /* Process one section of an object file. */
798 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
800 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
804 if (strncmp (name
, LTO_SECTION_PREFIX
, LTO_SECTION_PREFIX_LEN
) != 0)
807 s
= strrchr (name
, '.');
809 sscanf (s
, ".%x", &obj
->out
->id
);
810 secdata
= xmalloc (length
);
811 offset
+= obj
->file
->offset
;
812 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
)
813 || length
!= read (obj
->file
->fd
, secdata
, length
))
816 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
817 /* Force claim_file_handler to abandon this file. */
823 translate (secdata
, secdata
+ length
, obj
->out
);
829 /* Callback used by gold to check if the plugin will claim FILE. Writes
830 the result in CLAIMED. */
832 static enum ld_plugin_status
833 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
835 enum ld_plugin_status status
;
836 struct plugin_objfile obj
;
837 struct plugin_file_info lto_file
;
841 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
843 if (file
->offset
!= 0)
846 /* We pass the offset of the actual file, not the archive header.
847 Can't use PRIx64, because that's C99, so we have to print the
848 64-bit hex int as two 32-bit ones. */
850 lo
= file
->offset
& 0xffffffff;
851 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
852 int t
= hi
? asprintf (&objname
, "%s@0x%x%08x", file
->name
, lo
, hi
)
853 : asprintf (&objname
, "%s@0x%x", file
->name
, lo
);
854 check (t
>= 0, LDPL_FATAL
, "asprintf failed");
855 lto_file
.name
= objname
;
859 lto_file
.name
= xstrdup (file
->name
);
861 lto_file
.handle
= file
->handle
;
866 obj
.out
= <o_file
.symtab
;
868 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
870 /* No file, but also no error code means unrecognized format; just skip it. */
871 if (!obj
.objfile
&& !err
)
875 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
, &err
);
877 if (!obj
.objfile
|| errmsg
)
880 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
883 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
891 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
893 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
894 lto_file
.symtab
.syms
);
895 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
900 xrealloc (claimed_files
,
901 num_claimed_files
* sizeof (struct plugin_file_info
));
902 claimed_files
[num_claimed_files
- 1] = lto_file
;
907 free (lto_file
.name
);
911 simple_object_release_read (obj
.objfile
);
916 /* Parse the plugin options. */
919 process_option (const char *option
)
921 if (strcmp (option
, "-debug") == 0)
923 else if (strcmp (option
, "-nop") == 0)
925 else if (!strncmp (option
, "-pass-through=", strlen("-pass-through=")))
927 num_pass_through_items
++;
928 pass_through_items
= xrealloc (pass_through_items
,
929 num_pass_through_items
* sizeof (char *));
930 pass_through_items
[num_pass_through_items
- 1] =
931 xstrdup (option
+ strlen ("-pass-through="));
933 else if (!strncmp (option
, "-sym-style=", sizeof ("-sym-style=") - 1))
935 switch (option
[sizeof ("-sym-style=") - 1])
938 sym_style
= ss_win32
;
941 sym_style
= ss_uscore
;
951 char *opt
= xstrdup (option
);
952 lto_wrapper_num_args
+= 1;
953 size
= lto_wrapper_num_args
* sizeof (char *);
954 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
955 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
956 if (strncmp (option
, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
957 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
961 /* Called by gold after loading the plugin. TV is the transfer vector. */
963 enum ld_plugin_status
964 onload (struct ld_plugin_tv
*tv
)
966 struct ld_plugin_tv
*p
;
967 enum ld_plugin_status status
;
975 message
= p
->tv_u
.tv_message
;
977 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
978 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
980 case LDPT_ADD_SYMBOLS
:
981 add_symbols
= p
->tv_u
.tv_add_symbols
;
983 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
984 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
986 case LDPT_GET_SYMBOLS
:
987 get_symbols
= p
->tv_u
.tv_get_symbols
;
989 case LDPT_REGISTER_CLEANUP_HOOK
:
990 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
992 case LDPT_ADD_INPUT_FILE
:
993 add_input_file
= p
->tv_u
.tv_add_input_file
;
995 case LDPT_ADD_INPUT_LIBRARY
:
996 add_input_library
= p
->tv_u
.tv_add_input_library
;
999 process_option (p
->tv_u
.tv_string
);
1007 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1008 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1009 status
= register_claim_file (claim_file_handler
);
1010 check (status
== LDPS_OK
, LDPL_FATAL
,
1011 "could not register the claim_file callback");
1013 if (register_cleanup
)
1015 status
= register_cleanup (cleanup_handler
);
1016 check (status
== LDPS_OK
, LDPL_FATAL
,
1017 "could not register the cleanup callback");
1020 if (register_all_symbols_read
)
1022 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1023 status
= register_all_symbols_read (all_symbols_read_handler
);
1024 check (status
== LDPS_OK
, LDPL_FATAL
,
1025 "could not register the all_symbols_read callback");