1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
|
/* Plugin control for the GNU linker.
Copyright 2010, 2011 Free Software Foundation, Inc.
This file is part of the GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "sysdep.h"
#include "libiberty.h"
#include "bfd.h"
#include "bfdlink.h"
#include "bfdver.h"
#include "ld.h"
#include "ldmain.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldfile.h"
#include "plugin.h"
#include "plugin-api.h"
#include "elf-bfd.h"
#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
#include <windows.h>
#endif
/* Report plugin symbols. */
bfd_boolean report_plugin_symbols;
/* The suffix to append to the name of the real (claimed) object file
when generating a dummy BFD to hold the IR symbols sent from the
plugin. For cosmetic use only; appears in maps, crefs etc. */
#define IRONLY_SUFFIX " (symbol from plugin)"
/* Stores a single argument passed to a plugin. */
typedef struct plugin_arg
{
struct plugin_arg *next;
const char *arg;
} plugin_arg_t;
/* Holds all details of a single plugin. */
typedef struct plugin
{
/* Next on the list of plugins, or NULL at end of chain. */
struct plugin *next;
/* The argument string given to --plugin. */
const char *name;
/* The shared library handle returned by dlopen. */
void *dlhandle;
/* The list of argument string given to --plugin-opt. */
plugin_arg_t *args;
/* Number of args in the list, for convenience. */
size_t n_args;
/* The plugin's event handlers. */
ld_plugin_claim_file_handler claim_file_handler;
ld_plugin_all_symbols_read_handler all_symbols_read_handler;
ld_plugin_cleanup_handler cleanup_handler;
/* TRUE if the cleanup handlers have been called. */
bfd_boolean cleanup_done;
} plugin_t;
/* The master list of all plugins. */
static plugin_t *plugins_list = NULL;
/* We keep a tail pointer for easy linking on the end. */
static plugin_t **plugins_tail_chain_ptr = &plugins_list;
/* The last plugin added to the list, for receiving args. */
static plugin_t *last_plugin = NULL;
/* The tail of the arg chain of the last plugin added to the list. */
static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
/* The plugin which is currently having a callback executed. */
static plugin_t *called_plugin = NULL;
/* Last plugin to cause an error, if any. */
static const char *error_plugin = NULL;
/* A hash table that records symbols referenced by non-IR files. Used
at get_symbols time to determine whether any prevailing defs from
IR files are referenced only from other IR files, so tthat we can
we can distinguish the LDPR_PREVAILING_DEF and LDPR_PREVAILING_DEF_IRONLY
cases when establishing symbol resolutions. */
static struct bfd_hash_table *non_ironly_hash = NULL;
/* State of linker "notice" interface before we poked at it. */
static bfd_boolean orig_notice_all;
/* Original linker callbacks, and the plugin version. */
static const struct bfd_link_callbacks *orig_callbacks;
static struct bfd_link_callbacks plugin_callbacks;
/* Set at all symbols read time, to avoid recursively offering the plugin
its own newly-added input files and libs to claim. */
bfd_boolean no_more_claiming = FALSE;
/* List of tags to set in the constant leading part of the tv array. */
static const enum ld_plugin_tag tv_header_tags[] =
{
LDPT_MESSAGE,
LDPT_API_VERSION,
LDPT_GNU_LD_VERSION,
LDPT_LINKER_OUTPUT,
LDPT_OUTPUT_NAME,
LDPT_REGISTER_CLAIM_FILE_HOOK,
LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
LDPT_REGISTER_CLEANUP_HOOK,
LDPT_ADD_SYMBOLS,
LDPT_GET_INPUT_FILE,
LDPT_RELEASE_INPUT_FILE,
LDPT_GET_SYMBOLS,
LDPT_ADD_INPUT_FILE,
LDPT_ADD_INPUT_LIBRARY,
LDPT_SET_EXTRA_LIBRARY_PATH
};
/* How many entries in the constant leading part of the tv array. */
static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
/* Forward references. */
static bfd_boolean plugin_notice (struct bfd_link_info *info,
const char *name, bfd *abfd,
asection *section, bfd_vma value);
static bfd_boolean plugin_multiple_definition (struct bfd_link_info *info,
struct bfd_link_hash_entry *h,
bfd *nbfd,
asection *nsec,
bfd_vma nval);
#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
#define RTLD_NOW 0 /* Dummy value. */
static void *
dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
{
return LoadLibrary (file);
}
static void *
dlsym (void *handle, const char *name)
{
return GetProcAddress (handle, name);
}
static int
dlclose (void *handle)
{
FreeLibrary (handle);
return 0;
}
#endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
/* Helper function for exiting with error status. */
static int
set_plugin_error (const char *plugin)
{
error_plugin = plugin;
return -1;
}
/* Test if an error occurred. */
static bfd_boolean
plugin_error_p (void)
{
return error_plugin != NULL;
}
/* Return name of plugin which caused an error if any. */
const char *
plugin_error_plugin (void)
{
return error_plugin ? error_plugin : _("<no plugin>");
}
/* Handle -plugin arg: find and load plugin, or return error. */
int
plugin_opt_plugin (const char *plugin)
{
plugin_t *newplug;
newplug = xmalloc (sizeof *newplug);
memset (newplug, 0, sizeof *newplug);
newplug->name = plugin;
newplug->dlhandle = dlopen (plugin, RTLD_NOW);
if (!newplug->dlhandle)
return set_plugin_error (plugin);
/* Chain on end, so when we run list it is in command-line order. */
*plugins_tail_chain_ptr = newplug;
plugins_tail_chain_ptr = &newplug->next;
/* Record it as current plugin for receiving args. */
last_plugin = newplug;
last_plugin_args_tail_chain_ptr = &newplug->args;
return 0;
}
/* Accumulate option arguments for last-loaded plugin, or return
error if none. */
int
plugin_opt_plugin_arg (const char *arg)
{
plugin_arg_t *newarg;
if (!last_plugin)
return set_plugin_error (_("<no plugin>"));
newarg = xmalloc (sizeof *newarg);
newarg->arg = arg;
newarg->next = NULL;
/* Chain on end to preserve command-line order. */
*last_plugin_args_tail_chain_ptr = newarg;
last_plugin_args_tail_chain_ptr = &newarg->next;
last_plugin->n_args++;
return 0;
}
/* Create a dummy BFD. */
bfd *
plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
{
bfd *abfd;
bfd_use_reserved_id = 1;
abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
srctemplate);
if (abfd != NULL)
{
abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
if (bfd_make_writable (abfd)
&& bfd_copy_private_bfd_data (srctemplate, abfd))
{
flagword flags;
/* Create sections to own the symbols. */
flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
| SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
return abfd;
}
}
einfo (_("could not create dummy IR bfd: %F%E\n"));
return NULL;
}
/* Check if the BFD passed in is an IR dummy object file. */
static bfd_boolean
is_ir_dummy_bfd (const bfd *abfd)
{
/* ABFD can sometimes legitimately be NULL, e.g. when called from one
of the linker callbacks for a symbol in the *ABS* or *UND* sections.
Likewise, the usrdata field may be NULL if ABFD was added by the
backend without a corresponding input statement, as happens e.g.
when processing DT_NEEDED dependencies. */
return (abfd
&& abfd->usrdata
&& ((lang_input_statement_type *)(abfd->usrdata))->claimed);
}
/* Helpers to convert between BFD and GOLD symbol formats. */
static enum ld_plugin_status
asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
const struct ld_plugin_symbol *ldsym)
{
flagword flags = BSF_NO_FLAGS;
struct bfd_section *section;
asym->the_bfd = abfd;
asym->name = (ldsym->version
? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
: ldsym->name);
asym->value = 0;
switch (ldsym->def)
{
case LDPK_WEAKDEF:
flags = BSF_WEAK;
/* FALLTHRU */
case LDPK_DEF:
flags |= BSF_GLOBAL;
section = bfd_get_section_by_name (abfd, ".text");
break;
case LDPK_WEAKUNDEF:
flags = BSF_WEAK;
/* FALLTHRU */
case LDPK_UNDEF:
section = bfd_und_section_ptr;
break;
case LDPK_COMMON:
flags = BSF_GLOBAL;
section = bfd_com_section_ptr;
asym->value = ldsym->size;
/* For ELF targets, set alignment of common symbol to 1. */
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
break;
default:
return LDPS_ERR;
}
asym->flags = flags;
asym->section = section;
/* Visibility only applies on ELF targets. */
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
unsigned char visibility;
if (!elfsym)
einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
switch (ldsym->visibility)
{
default:
einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
ldsym->visibility);
case LDPV_DEFAULT:
visibility = STV_DEFAULT;
break;
case LDPV_PROTECTED:
visibility = STV_PROTECTED;
break;
case LDPV_INTERNAL:
visibility = STV_INTERNAL;
break;
case LDPV_HIDDEN:
visibility = STV_HIDDEN;
break;
}
elfsym->internal_elf_sym.st_other
= (visibility | (elfsym->internal_elf_sym.st_other
& ~ELF_ST_VISIBILITY (-1)));
}
return LDPS_OK;
}
/* Register a claim-file handler. */
static enum ld_plugin_status
register_claim_file (ld_plugin_claim_file_handler handler)
{
ASSERT (called_plugin);
called_plugin->claim_file_handler = handler;
return LDPS_OK;
}
/* Register an all-symbols-read handler. */
static enum ld_plugin_status
register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
{
ASSERT (called_plugin);
called_plugin->all_symbols_read_handler = handler;
return LDPS_OK;
}
/* Register a cleanup handler. */
static enum ld_plugin_status
register_cleanup (ld_plugin_cleanup_handler handler)
{
ASSERT (called_plugin);
called_plugin->cleanup_handler = handler;
return LDPS_OK;
}
/* Add symbols from a plugin-claimed input file. */
static enum ld_plugin_status
add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
{
asymbol **symptrs;
bfd *abfd = handle;
int n;
ASSERT (called_plugin);
symptrs = xmalloc (nsyms * sizeof *symptrs);
for (n = 0; n < nsyms; n++)
{
enum ld_plugin_status rv;
asymbol *bfdsym = bfd_make_empty_symbol (abfd);
symptrs[n] = bfdsym;
rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
if (rv != LDPS_OK)
return rv;
}
bfd_set_symtab (abfd, symptrs, nsyms);
return LDPS_OK;
}
/* Get the input file information with an open (possibly re-opened)
file descriptor. */
static enum ld_plugin_status
get_input_file (const void *handle, struct ld_plugin_input_file *file)
{
ASSERT (called_plugin);
handle = handle;
file = file;
return LDPS_ERR;
}
/* Release the input file. */
static enum ld_plugin_status
release_input_file (const void *handle)
{
ASSERT (called_plugin);
handle = handle;
return LDPS_ERR;
}
/* Return TRUE if a defined symbol might be reachable from outside the
universe of claimed objects. */
static inline bfd_boolean
is_visible_from_outside (struct ld_plugin_symbol *lsym, asection *section,
struct bfd_link_hash_entry *blhe)
{
/* Section's owner may be NULL if it is the absolute
section, fortunately is_ir_dummy_bfd handles that. */
if (!is_ir_dummy_bfd (section->owner))
return TRUE;
if (link_info.relocatable)
return TRUE;
if (link_info.export_dynamic || link_info.shared)
{
/* Only ELF symbols really have visibility. */
if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
{
struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
int vis = ELF_ST_VISIBILITY (el->other);
return vis == STV_DEFAULT || vis == STV_PROTECTED;
}
/* On non-ELF targets, we can safely make inferences by considering
what visibility the plugin would have liked to apply when it first
sent us the symbol. During ELF symbol processing, visibility only
ever becomes more restrictive, not less, when symbols are merged,
so this is a conservative estimate; it may give false positives,
declaring something visible from outside when it in fact would
not have been, but this will only lead to missed optimisation
opportunities during LTRANS at worst; it will not give false
negatives, which can lead to the disastrous conclusion that the
related symbol is IRONLY. (See GCC PR46319 for an example.) */
return (lsym->visibility == LDPV_DEFAULT
|| lsym->visibility == LDPV_PROTECTED);
}
return FALSE;
}
/* Get the symbol resolution info for a plugin-claimed input file. */
static enum ld_plugin_status
get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
{
const bfd *abfd = handle;
int n;
ASSERT (called_plugin);
for (n = 0; n < nsyms; n++)
{
struct bfd_link_hash_entry *blhe;
bfd_boolean ironly;
asection *owner_sec;
if (syms[n].def != LDPK_UNDEF)
blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
FALSE, FALSE, TRUE);
else
blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
syms[n].name, FALSE, FALSE, TRUE);
if (!blhe)
{
syms[n].resolution = LDPR_UNKNOWN;
goto report_symbol;
}
/* Determine resolution from blhe type and symbol's original type. */
if (blhe->type == bfd_link_hash_undefined
|| blhe->type == bfd_link_hash_undefweak)
{
syms[n].resolution = LDPR_UNDEF;
goto report_symbol;
}
if (blhe->type != bfd_link_hash_defined
&& blhe->type != bfd_link_hash_defweak
&& blhe->type != bfd_link_hash_common)
{
/* We should not have a new, indirect or warning symbol here. */
einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
called_plugin->name, blhe->type);
}
/* Find out which section owns the symbol. Since it's not undef,
it must have an owner; if it's not a common symbol, both defs
and weakdefs keep it in the same place. */
owner_sec = (blhe->type == bfd_link_hash_common
? blhe->u.c.p->section
: blhe->u.def.section);
/* We need to know if the sym is referenced from non-IR files. Or
even potentially-referenced, perhaps in a future final link if
this is a partial one, perhaps dynamically at load-time if the
symbol is externally visible. */
ironly = (!is_visible_from_outside (&syms[n], owner_sec, blhe)
&& !bfd_hash_lookup (non_ironly_hash, syms[n].name,
FALSE, FALSE));
/* If it was originally undefined or common, then it has been
resolved; determine how. */
if (syms[n].def == LDPK_UNDEF
|| syms[n].def == LDPK_WEAKUNDEF
|| syms[n].def == LDPK_COMMON)
{
if (owner_sec->owner == link_info.output_bfd)
syms[n].resolution = LDPR_RESOLVED_EXEC;
else if (owner_sec->owner == abfd)
syms[n].resolution = (ironly
? LDPR_PREVAILING_DEF_IRONLY
: LDPR_PREVAILING_DEF);
else if (is_ir_dummy_bfd (owner_sec->owner))
syms[n].resolution = LDPR_RESOLVED_IR;
else if (owner_sec->owner != NULL
&& (owner_sec->owner->flags & DYNAMIC) != 0)
syms[n].resolution = LDPR_RESOLVED_DYN;
else
syms[n].resolution = LDPR_RESOLVED_EXEC;
goto report_symbol;
}
/* Was originally def, or weakdef. Does it prevail? If the
owner is the original dummy bfd that supplied it, then this
is the definition that has prevailed. */
if (owner_sec->owner == link_info.output_bfd)
syms[n].resolution = LDPR_PREEMPTED_REG;
else if (owner_sec->owner == abfd)
{
syms[n].resolution = (ironly
? LDPR_PREVAILING_DEF_IRONLY
: LDPR_PREVAILING_DEF);
goto report_symbol;
}
/* Was originally def, weakdef, or common, but has been pre-empted. */
syms[n].resolution = (is_ir_dummy_bfd (owner_sec->owner)
? LDPR_PREEMPTED_IR
: LDPR_PREEMPTED_REG);
report_symbol:
if (report_plugin_symbols)
einfo (_("%P: %B: symbol `%s' "
"definition: %d, visibility: %d, resolution: %d\n"),
abfd, syms[n].name,
syms[n].def, syms[n].visibility, syms[n].resolution);
}
return LDPS_OK;
}
/* Add a new (real) input file generated by a plugin. */
static enum ld_plugin_status
add_input_file (const char *pathname)
{
ASSERT (called_plugin);
if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
NULL))
return LDPS_ERR;
return LDPS_OK;
}
/* Add a new (real) library required by a plugin. */
static enum ld_plugin_status
add_input_library (const char *pathname)
{
ASSERT (called_plugin);
if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
NULL))
return LDPS_ERR;
return LDPS_OK;
}
/* Set the extra library path to be used by libraries added via
add_input_library. */
static enum ld_plugin_status
set_extra_library_path (const char *path)
{
ASSERT (called_plugin);
ldfile_add_library_path (xstrdup (path), FALSE);
return LDPS_OK;
}
/* Issue a diagnostic message from a plugin. */
static enum ld_plugin_status
message (int level, const char *format, ...)
{
va_list args;
va_start (args, format);
switch (level)
{
case LDPL_INFO:
vfinfo (stdout, format, args, FALSE);
putchar ('\n');
break;
case LDPL_WARNING:
vfinfo (stdout, format, args, TRUE);
putchar ('\n');
break;
case LDPL_FATAL:
case LDPL_ERROR:
default:
{
char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F: " : "%P%X: ",
format, "\n", (const char *) NULL));
fflush (stdout);
vfinfo (stderr, newfmt, args, TRUE);
fflush (stderr);
}
break;
}
va_end (args);
return LDPS_OK;
}
/* Helper to size leading part of tv array and set it up. */
static size_t
set_tv_header (struct ld_plugin_tv *tv)
{
size_t i;
/* Version info. */
static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
if (!tv)
return tv_header_size;
for (i = 0; i < tv_header_size; i++)
{
tv[i].tv_tag = tv_header_tags[i];
#define TVU(x) tv[i].tv_u.tv_ ## x
switch (tv[i].tv_tag)
{
case LDPT_MESSAGE:
TVU(message) = message;
break;
case LDPT_API_VERSION:
TVU(val) = LD_PLUGIN_API_VERSION;
break;
case LDPT_GNU_LD_VERSION:
TVU(val) = major * 100 + minor;
break;
case LDPT_LINKER_OUTPUT:
TVU(val) = (link_info.relocatable
? LDPO_REL
: (link_info.shared ? LDPO_DYN : LDPO_EXEC));
break;
case LDPT_OUTPUT_NAME:
TVU(string) = output_filename;
break;
case LDPT_REGISTER_CLAIM_FILE_HOOK:
TVU(register_claim_file) = register_claim_file;
break;
case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
TVU(register_all_symbols_read) = register_all_symbols_read;
break;
case LDPT_REGISTER_CLEANUP_HOOK:
TVU(register_cleanup) = register_cleanup;
break;
case LDPT_ADD_SYMBOLS:
TVU(add_symbols) = add_symbols;
break;
case LDPT_GET_INPUT_FILE:
TVU(get_input_file) = get_input_file;
break;
case LDPT_RELEASE_INPUT_FILE:
TVU(release_input_file) = release_input_file;
break;
case LDPT_GET_SYMBOLS:
TVU(get_symbols) = get_symbols;
break;
case LDPT_ADD_INPUT_FILE:
TVU(add_input_file) = add_input_file;
break;
case LDPT_ADD_INPUT_LIBRARY:
TVU(add_input_library) = add_input_library;
break;
case LDPT_SET_EXTRA_LIBRARY_PATH:
TVU(set_extra_library_path) = set_extra_library_path;
break;
default:
/* Added a new entry to the array without adding
a new case to set up its value is a bug. */
FAIL ();
}
#undef TVU
}
return tv_header_size;
}
/* Append the per-plugin args list and trailing LDPT_NULL to tv. */
static void
set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
{
plugin_arg_t *arg = plugin->args;
while (arg)
{
tv->tv_tag = LDPT_OPTION;
tv->tv_u.tv_string = arg->arg;
arg = arg->next;
tv++;
}
tv->tv_tag = LDPT_NULL;
tv->tv_u.tv_val = 0;
}
/* Return true if any plugins are active this run. Only valid
after options have been processed. */
bfd_boolean
plugin_active_plugins_p (void)
{
return plugins_list != NULL;
}
/* Init the non_ironly hash table. */
static void
init_non_ironly_hash (void)
{
struct bfd_sym_chain *sym;
non_ironly_hash
= (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
if (!bfd_hash_table_init_n (non_ironly_hash,
bfd_hash_newfunc,
sizeof (struct bfd_hash_entry),
61))
einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
for (sym = &entry_symbol; sym != NULL; sym = sym->next)
if (sym->name
&& !bfd_hash_lookup (non_ironly_hash, sym->name, TRUE, TRUE))
einfo (_("%P%X: hash table failure adding symbol %s\n"),
sym->name);
}
/* Load up and initialise all plugins after argument parsing. */
int
plugin_load_plugins (void)
{
struct ld_plugin_tv *my_tv;
unsigned int max_args = 0;
plugin_t *curplug = plugins_list;
/* If there are no plugins, we need do nothing this run. */
if (!curplug)
return 0;
/* First pass over plugins to find max # args needed so that we
can size and allocate the tv array. */
while (curplug)
{
if (curplug->n_args > max_args)
max_args = curplug->n_args;
curplug = curplug->next;
}
/* Allocate tv array and initialise constant part. */
my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
set_tv_header (my_tv);
/* Pass over plugins again, activating them. */
curplug = plugins_list;
while (curplug)
{
enum ld_plugin_status rv;
ld_plugin_onload onloadfn = dlsym (curplug->dlhandle, "onload");
if (!onloadfn)
onloadfn = dlsym (curplug->dlhandle, "_onload");
if (!onloadfn)
return set_plugin_error (curplug->name);
set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
called_plugin = curplug;
rv = (*onloadfn) (my_tv);
called_plugin = NULL;
if (rv != LDPS_OK)
return set_plugin_error (curplug->name);
curplug = curplug->next;
}
/* Since plugin(s) inited ok, assume they're going to want symbol
resolutions, which needs us to track which symbols are referenced
by non-IR files using the linker's notice callback. */
orig_notice_all = link_info.notice_all;
orig_callbacks = link_info.callbacks;
plugin_callbacks = *orig_callbacks;
plugin_callbacks.notice = &plugin_notice;
link_info.notice_all = TRUE;
link_info.callbacks = &plugin_callbacks;
init_non_ironly_hash ();
return 0;
}
/* Call 'claim file' hook for all plugins. */
int
plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
{
plugin_t *curplug = plugins_list;
*claimed = FALSE;
if (no_more_claiming)
return 0;
while (curplug && !*claimed)
{
if (curplug->claim_file_handler)
{
enum ld_plugin_status rv;
called_plugin = curplug;
rv = (*curplug->claim_file_handler) (file, claimed);
called_plugin = NULL;
if (rv != LDPS_OK)
set_plugin_error (curplug->name);
}
curplug = curplug->next;
}
return plugin_error_p () ? -1 : 0;
}
/* Call 'all symbols read' hook for all plugins. */
int
plugin_call_all_symbols_read (void)
{
plugin_t *curplug = plugins_list;
/* Disable any further file-claiming. */
no_more_claiming = TRUE;
plugin_callbacks.multiple_definition = &plugin_multiple_definition;
while (curplug)
{
if (curplug->all_symbols_read_handler)
{
enum ld_plugin_status rv;
called_plugin = curplug;
rv = (*curplug->all_symbols_read_handler) ();
called_plugin = NULL;
if (rv != LDPS_OK)
set_plugin_error (curplug->name);
}
curplug = curplug->next;
}
return plugin_error_p () ? -1 : 0;
}
/* Call 'cleanup' hook for all plugins at exit. */
void
plugin_call_cleanup (void)
{
plugin_t *curplug = plugins_list;
while (curplug)
{
if (curplug->cleanup_handler && !curplug->cleanup_done)
{
enum ld_plugin_status rv;
curplug->cleanup_done = TRUE;
called_plugin = curplug;
rv = (*curplug->cleanup_handler) ();
called_plugin = NULL;
if (rv != LDPS_OK)
set_plugin_error (curplug->name);
dlclose (curplug->dlhandle);
}
curplug = curplug->next;
}
if (plugin_error_p ())
info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"),
plugin_error_plugin ());
}
/* To determine which symbols should be resolved LDPR_PREVAILING_DEF
and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
the linker adds them to the linker hash table. If we see a symbol
being referenced from a non-IR file, we add it to the non_ironly hash
table. If we can't find it there at get_symbols time, we know that
it was referenced only by IR files. We have to notice_all symbols,
because we won't necessarily know until later which ones will be
contributed by IR files. */
static bfd_boolean
plugin_notice (struct bfd_link_info *info,
const char *name,
bfd *abfd,
asection *section,
bfd_vma value)
{
if (name != NULL)
{
/* No further processing if this def/ref is from an IR dummy BFD. */
if (is_ir_dummy_bfd (abfd))
return TRUE;
/* We only care about refs, not defs, indicated by section
pointing to the undefined section (according to the bfd
linker notice callback interface definition). */
if (bfd_is_und_section (section))
{
/* This is a ref from a non-IR file, so note the ref'd
symbol in the non-IR-only hash. */
if (!bfd_hash_lookup (non_ironly_hash, name, TRUE, TRUE))
einfo (_("%P%X: %s: hash table failure adding symbol %s\n"),
abfd->filename, name);
}
}
/* Continue with cref/nocrossref/trace-sym processing. */
if (name == NULL
|| orig_notice_all
|| (info->notice_hash != NULL
&& bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
return (*orig_callbacks->notice) (info, name, abfd, section, value);
return TRUE;
}
/* When we add new object files to the link at all symbols read time,
these contain the real code and symbols generated from the IR files,
and so duplicate all the definitions already supplied by the dummy
IR-only BFDs that we created at claim files time. We use the linker's
multiple-definitions callback hook to fix up the clash, discarding
the symbol from the IR-only BFD in favour of the symbol from the
real BFD. We return true if this was not-really-a-clash because
we've fixed it up, or anyway if --allow-multiple-definition was in
effect (before we disabled it to ensure we got called back). */
static bfd_boolean
plugin_multiple_definition (struct bfd_link_info *info,
struct bfd_link_hash_entry *h,
bfd *nbfd, asection *nsec, bfd_vma nval)
{
if (h->type == bfd_link_hash_defined
&& is_ir_dummy_bfd (h->u.def.section->owner))
{
/* Replace it with new details. */
h->u.def.section = nsec;
h->u.def.value = nval;
return TRUE;
}
return (*orig_callbacks->multiple_definition) (info, h, nbfd, nsec, nval);
}
|