1 /* Test plugin for the GNU linker. Check non-object IR file and calling
2 release_input_file from onclaim_file.
3 Copyright (C) 2015 Free Software Foundation, Inc.
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 #include "plugin-api.h"
25 #include "filenames.h"
26 /* For ARRAY_SIZE macro only - we don't link the library itself. */
27 #include "libiberty.h"
29 extern enum ld_plugin_status
onload (struct ld_plugin_tv
*tv
);
30 static enum ld_plugin_status
onclaim_file (const struct ld_plugin_input_file
*file
,
32 static enum ld_plugin_status
onall_symbols_read (void);
33 static enum ld_plugin_status
oncleanup (void);
35 /* Helper for calling plugin api message function. */
36 #define TV_MESSAGE if (tv_message) (*tv_message)
38 /* Struct for recording files to claim / files claimed. */
39 typedef struct claim_file
41 struct claim_file
*next
;
42 struct ld_plugin_input_file file
;
44 struct ld_plugin_symbol
*symbols
;
49 /* Types of things that can be added at all symbols read time. */
50 typedef enum addfile_enum
57 /* Struct for recording files to add to final link. */
58 typedef struct add_file
60 struct add_file
*next
;
65 /* Helper macro for defining array of transfer vector tags and names. */
66 #define ADDENTRY(tag) { tag, #tag }
68 /* Struct for looking up human-readable versions of tag names. */
69 typedef struct tag_name
71 enum ld_plugin_tag tag
;
75 /* Array of all known tags and their names. */
76 static const tag_name_t tag_names
[] =
79 ADDENTRY(LDPT_API_VERSION
),
80 ADDENTRY(LDPT_GOLD_VERSION
),
81 ADDENTRY(LDPT_LINKER_OUTPUT
),
82 ADDENTRY(LDPT_OPTION
),
83 ADDENTRY(LDPT_REGISTER_CLAIM_FILE_HOOK
),
84 ADDENTRY(LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
),
85 ADDENTRY(LDPT_REGISTER_CLEANUP_HOOK
),
86 ADDENTRY(LDPT_ADD_SYMBOLS
),
87 ADDENTRY(LDPT_GET_SYMBOLS
),
88 ADDENTRY(LDPT_GET_SYMBOLS_V2
),
89 ADDENTRY(LDPT_ADD_INPUT_FILE
),
90 ADDENTRY(LDPT_MESSAGE
),
91 ADDENTRY(LDPT_GET_INPUT_FILE
),
92 ADDENTRY(LDPT_GET_VIEW
),
93 ADDENTRY(LDPT_RELEASE_INPUT_FILE
),
94 ADDENTRY(LDPT_ADD_INPUT_LIBRARY
),
95 ADDENTRY(LDPT_OUTPUT_NAME
),
96 ADDENTRY(LDPT_SET_EXTRA_LIBRARY_PATH
),
97 ADDENTRY(LDPT_GNU_LD_VERSION
)
100 /* Function pointers to cache hooks passed at onload time. */
101 static ld_plugin_register_claim_file tv_register_claim_file
= 0;
102 static ld_plugin_register_all_symbols_read tv_register_all_symbols_read
= 0;
103 static ld_plugin_register_cleanup tv_register_cleanup
= 0;
104 static ld_plugin_add_symbols tv_add_symbols
= 0;
105 static ld_plugin_get_symbols tv_get_symbols
= 0;
106 static ld_plugin_get_symbols tv_get_symbols_v2
= 0;
107 static ld_plugin_add_input_file tv_add_input_file
= 0;
108 static ld_plugin_message tv_message
= 0;
109 static ld_plugin_get_input_file tv_get_input_file
= 0;
110 static ld_plugin_get_view tv_get_view
= 0;
111 static ld_plugin_release_input_file tv_release_input_file
= 0;
112 static ld_plugin_add_input_library tv_add_input_library
= 0;
113 static ld_plugin_set_extra_library_path tv_set_extra_library_path
= 0;
115 /* Other cached info from the transfer vector. */
116 static enum ld_plugin_output_file_type linker_output
;
117 static const char *output_name
;
119 /* Behaviour control flags set by plugin options. */
120 static enum ld_plugin_status onload_ret
= LDPS_OK
;
121 static enum ld_plugin_status claim_file_ret
= LDPS_OK
;
122 static enum ld_plugin_status all_symbols_read_ret
= LDPS_OK
;
123 static enum ld_plugin_status cleanup_ret
= LDPS_OK
;
124 static bfd_boolean register_claimfile_hook
= TRUE
;
125 static bfd_boolean register_allsymbolsread_hook
= FALSE
;
126 static bfd_boolean register_cleanup_hook
= FALSE
;
127 static bfd_boolean dumpresolutions
= FALSE
;
129 /* The master list of all claimable/claimed files. */
130 static claim_file_t
*claimfiles_list
= NULL
;
132 /* We keep a tail pointer for easy linking on the end. */
133 static claim_file_t
**claimfiles_tail_chain_ptr
= &claimfiles_list
;
135 /* The last claimed file added to the list, for receiving syms. */
136 static claim_file_t
*last_claimfile
= NULL
;
138 /* The master list of all files to add to the final link. */
139 static add_file_t
*addfiles_list
= NULL
;
141 /* We keep a tail pointer for easy linking on the end. */
142 static add_file_t
**addfiles_tail_chain_ptr
= &addfiles_list
;
144 /* Add a new claimfile on the end of the chain. */
145 static enum ld_plugin_status
146 record_claim_file (const char *file
, off_t filesize
)
148 claim_file_t
*newfile
;
150 newfile
= malloc (sizeof *newfile
);
153 memset (newfile
, 0, sizeof *newfile
);
154 /* Only setup for now is remembering the name to look for. */
155 newfile
->file
.name
= file
;
156 newfile
->file
.filesize
= filesize
;
157 /* Chain it on the end of the list. */
158 *claimfiles_tail_chain_ptr
= newfile
;
159 claimfiles_tail_chain_ptr
= &newfile
->next
;
160 /* Record it as active for receiving symbols to register. */
161 last_claimfile
= newfile
;
165 /* Add a new addfile on the end of the chain. */
166 static enum ld_plugin_status
167 record_add_file (const char *file
, addfile_enum_t type
)
171 newfile
= malloc (sizeof *newfile
);
174 newfile
->next
= NULL
;
175 newfile
->name
= file
;
176 newfile
->type
= type
;
177 /* Chain it on the end of the list. */
178 *addfiles_tail_chain_ptr
= newfile
;
179 addfiles_tail_chain_ptr
= &newfile
->next
;
183 /* Parse a command-line argument string into a symbol definition.
184 Symbol-strings follow the colon-separated format:
185 NAME:VERSION:def:vis:size:COMDATKEY
186 where the fields in capitals are strings and those in lower
187 case are integers. We don't allow to specify a resolution as
188 doing so is not meaningful when calling the add symbols hook. */
189 static enum ld_plugin_status
190 parse_symdefstr (const char *str
, struct ld_plugin_symbol
*sym
)
194 const char *colon1
, *colon2
, *colon5
;
196 /* Locate the colons separating the first two strings. */
197 colon1
= strchr (str
, ':');
200 colon2
= strchr (colon1
+1, ':');
203 /* Name must not be empty (version may be). */
207 /* The fifth colon and trailing comdat key string are optional,
208 but the intermediate ones must all be present. */
209 colon5
= strchr (colon2
+1, ':'); /* Actually only third so far. */
212 colon5
= strchr (colon5
+1, ':'); /* Hopefully fourth now. */
215 colon5
= strchr (colon5
+1, ':'); /* Optional fifth now. */
217 /* Finally we'll use sscanf to parse the numeric fields, then
218 we'll split out the strings which we need to allocate separate
219 storage for anyway so that we can add nul termination. */
220 n
= sscanf (colon2
+ 1, "%i:%i:%lli", &sym
->def
, &sym
->visibility
, &size
);
224 /* Parsed successfully, so allocate strings and fill out fields. */
226 sym
->resolution
= LDPR_UNKNOWN
;
227 sym
->name
= malloc (colon1
- str
+ 1);
230 memcpy (sym
->name
, str
, colon1
- str
);
231 sym
->name
[colon1
- str
] = '\0';
232 if (colon2
> (colon1
+ 1))
234 sym
->version
= malloc (colon2
- colon1
);
237 memcpy (sym
->version
, colon1
+ 1, colon2
- (colon1
+ 1));
238 sym
->version
[colon2
- (colon1
+ 1)] = '\0';
242 if (colon5
&& colon5
[1])
244 sym
->comdat_key
= malloc (strlen (colon5
+ 1) + 1);
245 if (!sym
->comdat_key
)
247 strcpy (sym
->comdat_key
, colon5
+ 1);
254 /* Record a symbol to be added for the last-added claimfile. */
255 static enum ld_plugin_status
256 record_claimed_file_symbol (const char *symdefstr
)
258 struct ld_plugin_symbol sym
;
260 /* Can't add symbols except as belonging to claimed files. */
264 /* If string doesn't parse correctly, give an error. */
265 if (parse_symdefstr (symdefstr
, &sym
) != LDPS_OK
)
268 /* Check for enough space, resize array if needed, and add it. */
269 if (last_claimfile
->n_syms_allocated
== last_claimfile
->n_syms_used
)
271 int new_n_syms
= last_claimfile
->n_syms_allocated
272 ? 2 * last_claimfile
->n_syms_allocated
274 last_claimfile
->symbols
= realloc (last_claimfile
->symbols
,
275 new_n_syms
* sizeof *last_claimfile
->symbols
);
276 if (!last_claimfile
->symbols
)
278 last_claimfile
->n_syms_allocated
= new_n_syms
;
280 last_claimfile
->symbols
[last_claimfile
->n_syms_used
++] = sym
;
285 /* Records the status to return from one of the registered hooks. */
286 static enum ld_plugin_status
287 set_ret_val (const char *whichval
, enum ld_plugin_status retval
)
289 if (!strcmp ("onload", whichval
))
291 else if (!strcmp ("claimfile", whichval
))
292 claim_file_ret
= retval
;
293 else if (!strcmp ("allsymbolsread", whichval
))
294 all_symbols_read_ret
= retval
;
295 else if (!strcmp ("cleanup", whichval
))
296 cleanup_ret
= retval
;
302 /* Records hooks which should be registered. */
303 static enum ld_plugin_status
304 set_register_hook (const char *whichhook
, bfd_boolean yesno
)
306 if (!strcmp ("claimfile", whichhook
))
307 register_claimfile_hook
= yesno
;
308 else if (!strcmp ("allsymbolsread", whichhook
))
309 register_allsymbolsread_hook
= yesno
;
310 else if (!strcmp ("cleanup", whichhook
))
311 register_cleanup_hook
= yesno
;
317 /* Determine type of plugin option and pass to individual parsers. */
318 static enum ld_plugin_status
319 parse_option (const char *opt
)
321 if (!strncmp ("fail", opt
, 4))
322 return set_ret_val (opt
+ 4, LDPS_ERR
);
323 else if (!strncmp ("pass", opt
, 4))
324 return set_ret_val (opt
+ 4, LDPS_OK
);
325 else if (!strncmp ("register", opt
, 8))
326 return set_register_hook (opt
+ 8, TRUE
);
327 else if (!strncmp ("noregister", opt
, 10))
328 return set_register_hook (opt
+ 10, FALSE
);
329 else if (!strncmp ("claim:", opt
, 6))
330 return record_claim_file (opt
+ 6, 0);
331 else if (!strncmp ("sym:", opt
, 4))
332 return record_claimed_file_symbol (opt
+ 4);
333 else if (!strncmp ("add:", opt
, 4))
334 return record_add_file (opt
+ 4, ADD_FILE
);
335 else if (!strncmp ("lib:", opt
, 4))
336 return record_add_file (opt
+ 4, ADD_LIB
);
337 else if (!strncmp ("dir:", opt
, 4))
338 return record_add_file (opt
+ 4, ADD_DIR
);
339 else if (!strcmp ("dumpresolutions", opt
))
340 dumpresolutions
= TRUE
;
346 /* Output contents of transfer vector array entry in human-readable form. */
348 dump_tv_tag (size_t n
, struct ld_plugin_tv
*tv
)
354 for (tag
= 0; tag
< ARRAY_SIZE (tag_names
); tag
++)
355 if (tag_names
[tag
].tag
== tv
->tv_tag
)
357 sprintf (unknownbuf
, "unknown tag #%d", tv
->tv_tag
);
358 name
= (tag
< ARRAY_SIZE (tag_names
)) ? tag_names
[tag
].name
: unknownbuf
;
362 case LDPT_OUTPUT_NAME
:
363 TV_MESSAGE (LDPL_INFO
, "tv[%d]: %s '%s'", n
, name
,
366 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
367 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
368 case LDPT_REGISTER_CLEANUP_HOOK
:
369 case LDPT_ADD_SYMBOLS
:
370 case LDPT_GET_SYMBOLS
:
371 case LDPT_GET_SYMBOLS_V2
:
372 case LDPT_ADD_INPUT_FILE
:
374 case LDPT_GET_INPUT_FILE
:
376 case LDPT_RELEASE_INPUT_FILE
:
377 case LDPT_ADD_INPUT_LIBRARY
:
378 case LDPT_SET_EXTRA_LIBRARY_PATH
:
379 TV_MESSAGE (LDPL_INFO
, "tv[%d]: %s func@0x%p", n
, name
,
380 (void *)(tv
->tv_u
.tv_message
));
383 case LDPT_API_VERSION
:
384 case LDPT_GOLD_VERSION
:
385 case LDPT_LINKER_OUTPUT
:
386 case LDPT_GNU_LD_VERSION
:
388 TV_MESSAGE (LDPL_INFO
, "tv[%d]: %s value %W (%d)", n
, name
,
389 (bfd_vma
)tv
->tv_u
.tv_val
, tv
->tv_u
.tv_val
);
394 /* Handle/record information received in a transfer vector entry. */
395 static enum ld_plugin_status
396 parse_tv_tag (struct ld_plugin_tv
*tv
)
398 #define SETVAR(x) x = tv->tv_u.x
402 return parse_option (tv
->tv_u
.tv_string
);
404 case LDPT_GOLD_VERSION
:
405 case LDPT_GNU_LD_VERSION
:
406 case LDPT_API_VERSION
:
409 case LDPT_OUTPUT_NAME
:
410 output_name
= tv
->tv_u
.tv_string
;
412 case LDPT_LINKER_OUTPUT
:
413 linker_output
= tv
->tv_u
.tv_val
;
415 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
416 SETVAR(tv_register_claim_file
);
418 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
419 SETVAR(tv_register_all_symbols_read
);
421 case LDPT_REGISTER_CLEANUP_HOOK
:
422 SETVAR(tv_register_cleanup
);
424 case LDPT_ADD_SYMBOLS
:
425 SETVAR(tv_add_symbols
);
427 case LDPT_GET_SYMBOLS
:
428 SETVAR(tv_get_symbols
);
430 case LDPT_GET_SYMBOLS_V2
:
431 tv_get_symbols_v2
= tv
->tv_u
.tv_get_symbols
;
433 case LDPT_ADD_INPUT_FILE
:
434 SETVAR(tv_add_input_file
);
439 case LDPT_GET_INPUT_FILE
:
440 SETVAR(tv_get_input_file
);
445 case LDPT_RELEASE_INPUT_FILE
:
446 SETVAR(tv_release_input_file
);
448 case LDPT_ADD_INPUT_LIBRARY
:
449 SETVAR(tv_add_input_library
);
451 case LDPT_SET_EXTRA_LIBRARY_PATH
:
452 SETVAR(tv_set_extra_library_path
);
459 /* Standard plugin API entry point. */
460 enum ld_plugin_status
461 onload (struct ld_plugin_tv
*tv
)
463 enum ld_plugin_status rv
;
465 /* This plugin does nothing but dump the tv array. It would
466 be an error if this function was called without one. */
470 /* First entry should always be LDPT_MESSAGE, letting us get
471 hold of it easily so we can send output straight away. */
472 if (tv
[0].tv_tag
== LDPT_MESSAGE
)
473 tv_message
= tv
[0].tv_u
.tv_message
;
476 if ((rv
= parse_tv_tag (tv
)) != LDPS_OK
)
478 while ((tv
++)->tv_tag
!= LDPT_NULL
);
480 /* Register hooks only if instructed by options. */
481 if (register_claimfile_hook
)
483 if (!tv_register_claim_file
)
485 TV_MESSAGE (LDPL_FATAL
, "No register_claim_file hook");
489 (*tv_register_claim_file
) (onclaim_file
);
491 if (register_allsymbolsread_hook
)
493 if (!tv_register_all_symbols_read
)
495 TV_MESSAGE (LDPL_FATAL
, "No register_all_symbols_read hook");
499 (*tv_register_all_symbols_read
) (onall_symbols_read
);
501 if (register_cleanup_hook
)
503 if (!tv_register_cleanup
)
505 TV_MESSAGE (LDPL_FATAL
, "No register_cleanup hook");
509 (*tv_register_cleanup
) (oncleanup
);
512 /* Claim testsuite/ld-plugin/func.c, standalone or in a library. Its
513 size must be SIZE_OF_FUNC_C bytes. */
514 #define SIZE_OF_FUNC_C 248
515 if (onload_ret
== LDPS_OK
516 && (record_claim_file ("func.c", SIZE_OF_FUNC_C
) != LDPS_OK
517 || record_claimed_file_symbol ("func::0:0:0") != LDPS_OK
518 || record_claimed_file_symbol ("_func::0:0:0") != LDPS_OK
519 || record_claim_file ("libfunc.a", SIZE_OF_FUNC_C
) != LDPS_OK
520 || record_claimed_file_symbol ("func::0:0:0") != LDPS_OK
521 || record_claimed_file_symbol ("_func::0:0:0") != LDPS_OK
))
522 onload_ret
= LDPS_ERR
;
528 xstrdup (const char *s
)
530 size_t len
= strlen (s
) + 1;
531 char *ret
= malloc (len
+ 1);
532 return (char *) memcpy (ret
, s
, len
);
535 /* Standard plugin API registerable hook. */
536 static enum ld_plugin_status
537 onclaim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
539 /* Let's see if we want to claim this file. */
540 claim_file_t
*claimfile
= claimfiles_list
;
541 size_t len
= strlen (file
->name
);
542 char *name
= xstrdup (file
->name
);
543 char *p
= name
+ len
;
546 /* Only match the file name without the directory part. */
547 islib
= *p
== 'a' && *(p
- 1) == '.';
548 for (; p
!= name
; p
--)
549 if (IS_DIR_SEPARATOR (*p
))
557 /* Claim the file only if the file name and size match and don't
558 match the whole library. */
559 if (!strcmp (p
, claimfile
->file
.name
)
560 && claimfile
->file
.filesize
== file
->filesize
561 && (!islib
|| file
->offset
!= 0))
563 claimfile
= claimfile
->next
;
568 /* If we decided to claim it, record that fact, and add any symbols
569 that were defined for it by plugin options. */
570 *claimed
= (claimfile
!= 0);
576 TV_MESSAGE (LDPL_INFO
, "Claimed: %s [@%ld/%ld]", file
->name
,
577 (long)file
->offset
, (long)file
->filesize
);
579 claimfile
->claimed
= TRUE
;
580 claimfile
->file
= *file
;
581 if (claimfile
->n_syms_used
&& !tv_add_symbols
)
582 claim_file_ret
= LDPS_ERR
;
583 else if (claimfile
->n_syms_used
)
584 claim_file_ret
= (*tv_add_symbols
) (claimfile
->file
.handle
,
585 claimfile
->n_syms_used
,
588 fd
= claimfile
->file
.fd
;
589 name
= xstrdup (claimfile
->file
.name
);
590 claim_file_ret
= tv_release_input_file (claimfile
->file
.handle
);
591 if (claim_file_ret
!= LDPS_OK
)
594 return claim_file_ret
;
596 if (read (fd
, buffer
, sizeof (buffer
)) >= 0)
598 claim_file_ret
== LDPS_ERR
;
599 TV_MESSAGE (LDPL_FATAL
, "Unreleased file descriptor on: %s", name
);
604 return claim_file_ret
;
607 /* Standard plugin API registerable hook. */
608 static enum ld_plugin_status
609 onall_symbols_read (void)
611 static const char *resolutions
[] =
615 "LDPR_PREVAILING_DEF",
616 "LDPR_PREVAILING_DEF_IRONLY",
617 "LDPR_PREEMPTED_REG",
620 "LDPR_RESOLVED_EXEC",
622 "LDPR_PREVAILING_DEF_IRONLY_EXP",
624 claim_file_t
*claimfile
= dumpresolutions
? claimfiles_list
: NULL
;
625 add_file_t
*addfile
= addfiles_list
;
626 TV_MESSAGE (LDPL_INFO
, "hook called: all symbols read.");
627 for ( ; claimfile
; claimfile
= claimfile
->next
)
629 enum ld_plugin_status rv
;
631 if (claimfile
->n_syms_used
&& !tv_get_symbols_v2
)
633 else if (!claimfile
->n_syms_used
)
635 else if (!claimfile
->file
.handle
)
637 rv
= tv_get_symbols_v2 (claimfile
->file
.handle
, claimfile
->n_syms_used
,
641 for (n
= 0; n
< claimfile
->n_syms_used
; n
++)
642 TV_MESSAGE (LDPL_INFO
, "Sym: '%s%s%s' Resolution: %s",
643 claimfile
->symbols
[n
].name
,
644 claimfile
->symbols
[n
].version
? "@" : "",
645 (claimfile
->symbols
[n
].version
646 ? claimfile
->symbols
[n
].version
: ""),
647 resolutions
[claimfile
->symbols
[n
].resolution
]);
649 for ( ; addfile
; addfile
= addfile
->next
)
651 enum ld_plugin_status rv
;
652 if (addfile
->type
== ADD_LIB
&& tv_add_input_library
)
653 rv
= (*tv_add_input_library
) (addfile
->name
);
654 else if (addfile
->type
== ADD_FILE
&& tv_add_input_file
)
655 rv
= (*tv_add_input_file
) (addfile
->name
);
656 else if (addfile
->type
== ADD_DIR
&& tv_set_extra_library_path
)
657 rv
= (*tv_set_extra_library_path
) (addfile
->name
);
664 return all_symbols_read_ret
;
667 /* Standard plugin API registerable hook. */
668 static enum ld_plugin_status
671 TV_MESSAGE (LDPL_INFO
, "hook called: cleanup.");