ld/testplug.c

   1 /* Test plugin for the GNU linker.
   2    Copyright (C) 2010-2020 Free Software Foundation, Inc.
   3
   4    This file is part of the GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "plugin-api.h"
  24 /* For ARRAY_SIZE macro only - we don't link the library itself.  */
  25 #include "libiberty.h"
  26
  27 #include <ctype.h> /* For isdigit.  */
  28
  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,
  31                                 int *claimed);
  32 static enum ld_plugin_status onall_symbols_read (void);
  33 static enum ld_plugin_status oncleanup (void);
  34
  35 /* Helper for calling plugin api message function.  */
  36 #define TV_MESSAGE if (tv_message) (*tv_message)
  37
  38 /* Struct for recording files to claim / files claimed.  */
  39 typedef struct claim_file
  40 {
  41   struct claim_file *next;
  42   struct ld_plugin_input_file file;
  43   bfd_boolean claimed;
  44   struct ld_plugin_symbol *symbols;
  45   int n_syms_allocated;
  46   int n_syms_used;
  47 } claim_file_t;
  48
  49 /* Types of things that can be added at all symbols read time.  */
  50 typedef enum addfile_enum
  51 {
  52   ADD_FILE,
  53   ADD_LIB,
  54   ADD_DIR
  55 } addfile_enum_t;
  56
  57 /* Struct for recording files to add to final link.  */
  58 typedef struct add_file
  59 {
  60   struct add_file *next;
  61   const char *name;
  62   addfile_enum_t type;
  63 } add_file_t;
  64
  65 /* Helper macro for defining array of transfer vector tags and names.  */
  66 #define ADDENTRY(tag) { tag, #tag }
  67
  68 /* Struct for looking up human-readable versions of tag names.  */
  69 typedef struct tag_name
  70 {
  71   enum ld_plugin_tag tag;
  72   const char *name;
  73 } tag_name_t;
  74
  75 /* Array of all known tags and their names.  */
  76 static const tag_name_t tag_names[] =
  77 {
  78   ADDENTRY(LDPT_NULL),
  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)
  98 };
  99
 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;
 114
 115 /* Other cached info from the transfer vector.  */
 116 static enum ld_plugin_output_file_type linker_output;
 117 static const char *output_name;
 118
 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 = FALSE;
 125 static bfd_boolean register_allsymbolsread_hook = FALSE;
 126 static bfd_boolean register_cleanup_hook = FALSE;
 127 static bfd_boolean dumpresolutions = FALSE;
 128
 129 /* The master list of all claimable/claimed files.  */
 130 static claim_file_t *claimfiles_list = NULL;
 131
 132 /* We keep a tail pointer for easy linking on the end.  */
 133 static claim_file_t **claimfiles_tail_chain_ptr = &claimfiles_list;
 134
 135 /* The last claimed file added to the list, for receiving syms.  */
 136 static claim_file_t *last_claimfile = NULL;
 137
 138 /* The master list of all files to add to the final link.  */
 139 static add_file_t *addfiles_list = NULL;
 140
 141 /* We keep a tail pointer for easy linking on the end.  */
 142 static add_file_t **addfiles_tail_chain_ptr = &addfiles_list;
 143
 144 /* Number of bytes read in claim file before deciding if the file can be
 145    claimed.  */
 146 static int bytes_to_read_before_claim = 0;
 147
 148 /* Add a new claimfile on the end of the chain.  */
 149 static enum ld_plugin_status
 150 record_claim_file (const char *file)
 151 {
 152   claim_file_t *newfile;
 153
 154   newfile = malloc (sizeof *newfile);
 155   if (!newfile)
 156     return LDPS_ERR;
 157   memset (newfile, 0, sizeof *newfile);
 158   /* Only setup for now is remembering the name to look for.  */
 159   newfile->file.name = file;
 160   /* Chain it on the end of the list.  */
 161   *claimfiles_tail_chain_ptr = newfile;
 162   claimfiles_tail_chain_ptr = &newfile->next;
 163   /* Record it as active for receiving symbols to register.  */
 164   last_claimfile = newfile;
 165   return LDPS_OK;
 166 }
 167
 168 /* How many bytes to read before claiming (or not) an input file.  */
 169 static enum ld_plugin_status
 170 record_read_length (const char *length)
 171 {
 172   const char *tmp;
 173
 174   tmp = length;
 175   while (*tmp != '\0' && isdigit (*tmp))
 176     ++tmp;
 177   if (*tmp != '\0' || *length == '\0')
 178     {
 179       fprintf (stderr, "APB: Bad length string: %s\n", tmp);
 180       return LDPS_ERR;
 181     }
 182
 183   bytes_to_read_before_claim = atoi (length);
 184   return LDPS_OK;
 185 }
 186
 187 /* Add a new addfile on the end of the chain.  */
 188 static enum ld_plugin_status
 189 record_add_file (const char *file, addfile_enum_t type)
 190 {
 191   add_file_t *newfile;
 192
 193   newfile = malloc (sizeof *newfile);
 194   if (!newfile)
 195     return LDPS_ERR;
 196   newfile->next = NULL;
 197   newfile->name = file;
 198   newfile->type = type;
 199   /* Chain it on the end of the list.  */
 200   *addfiles_tail_chain_ptr = newfile;
 201   addfiles_tail_chain_ptr = &newfile->next;
 202   return LDPS_OK;
 203 }
 204
 205 /* Parse a command-line argument string into a symbol definition.
 206    Symbol-strings follow the colon-separated format:
 207         NAME:VERSION:def:vis:size:COMDATKEY
 208    where the fields in capitals are strings and those in lower
 209    case are integers.  We don't allow to specify a resolution as
 210    doing so is not meaningful when calling the add symbols hook.  */
 211 static enum ld_plugin_status
 212 parse_symdefstr (const char *str, struct ld_plugin_symbol *sym)
 213 {
 214   int n;
 215   long long size;
 216   const char *colon1, *colon2, *colon5;
 217
 218   /* Locate the colons separating the first two strings.  */
 219   colon1 = strchr (str, ':');
 220   if (!colon1)
 221     return LDPS_ERR;
 222   colon2 = strchr (colon1+1, ':');
 223   if (!colon2)
 224     return LDPS_ERR;
 225   /* Name must not be empty (version may be).  */
 226   if (colon1 == str)
 227     return LDPS_ERR;
 228
 229   /* The fifth colon and trailing comdat key string are optional,
 230      but the intermediate ones must all be present.  */
 231   colon5 = strchr (colon2+1, ':');      /* Actually only third so far.  */
 232   if (!colon5)
 233     return LDPS_ERR;
 234   colon5 = strchr (colon5+1, ':');      /* Hopefully fourth now.  */
 235   if (!colon5)
 236     return LDPS_ERR;
 237   colon5 = strchr (colon5+1, ':');      /* Optional fifth now.  */
 238
 239   /* Finally we'll use sscanf to parse the numeric fields, then
 240      we'll split out the strings which we need to allocate separate
 241      storage for anyway so that we can add nul termination.  */
 242   n = sscanf (colon2 + 1, "%i:%i:%lli", &sym->def, &sym->visibility, &size);
 243   if (n != 3)
 244     return LDPS_ERR;
 245
 246   /* Parsed successfully, so allocate strings and fill out fields.  */
 247   sym->size = size;
 248   sym->resolution = LDPR_UNKNOWN;
 249   sym->name = malloc (colon1 - str + 1);
 250   if (!sym->name)
 251     return LDPS_ERR;
 252   memcpy (sym->name, str, colon1 - str);
 253   sym->name[colon1 - str] = '\0';
 254   if (colon2 > (colon1 + 1))
 255     {
 256       sym->version = malloc (colon2 - colon1);
 257       if (!sym->version)
 258         return LDPS_ERR;
 259       memcpy (sym->version, colon1 + 1, colon2 - (colon1 + 1));
 260       sym->version[colon2 - (colon1 + 1)] = '\0';
 261     }
 262   else
 263     sym->version = NULL;
 264   if (colon5 && colon5[1])
 265     {
 266       sym->comdat_key = malloc (strlen (colon5 + 1) + 1);
 267       if (!sym->comdat_key)
 268         return LDPS_ERR;
 269       strcpy (sym->comdat_key, colon5 + 1);
 270     }
 271   else
 272     sym->comdat_key = 0;
 273   return LDPS_OK;
 274 }
 275
 276 /* Record a symbol to be added for the last-added claimfile.  */
 277 static enum ld_plugin_status
 278 record_claimed_file_symbol (const char *symdefstr)
 279 {
 280   struct ld_plugin_symbol sym;
 281
 282   /* Can't add symbols except as belonging to claimed files.  */
 283   if (!last_claimfile)
 284     return LDPS_ERR;
 285
 286   /* If string doesn't parse correctly, give an error.  */
 287   if (parse_symdefstr (symdefstr, &sym) != LDPS_OK)
 288     return LDPS_ERR;
 289
 290   /* Check for enough space, resize array if needed, and add it.  */
 291   if (last_claimfile->n_syms_allocated == last_claimfile->n_syms_used)
 292     {
 293       int new_n_syms = last_claimfile->n_syms_allocated
 294                         ? 2 * last_claimfile->n_syms_allocated
 295                         : 10;
 296       last_claimfile->symbols = realloc (last_claimfile->symbols,
 297                         new_n_syms * sizeof *last_claimfile->symbols);
 298       if (!last_claimfile->symbols)
 299         return LDPS_ERR;
 300       last_claimfile->n_syms_allocated = new_n_syms;
 301     }
 302   last_claimfile->symbols[last_claimfile->n_syms_used++] = sym;
 303
 304   return LDPS_OK;
 305 }
 306
 307 /* Records the status to return from one of the registered hooks.  */
 308 static enum ld_plugin_status
 309 set_ret_val (const char *whichval, enum ld_plugin_status retval)
 310 {
 311   if (!strcmp ("onload", whichval))
 312     onload_ret = retval;
 313   else if (!strcmp ("claimfile", whichval))
 314     claim_file_ret = retval;
 315   else if (!strcmp ("allsymbolsread", whichval))
 316     all_symbols_read_ret = retval;
 317   else if (!strcmp ("cleanup", whichval))
 318     cleanup_ret = retval;
 319   else
 320     return LDPS_ERR;
 321   return LDPS_OK;
 322 }
 323
 324 /* Records hooks which should be registered.  */
 325 static enum ld_plugin_status
 326 set_register_hook (const char *whichhook, bfd_boolean yesno)
 327 {
 328   if (!strcmp ("claimfile", whichhook))
 329     register_claimfile_hook = yesno;
 330   else if (!strcmp ("allsymbolsread", whichhook))
 331     register_allsymbolsread_hook = yesno;
 332   else if (!strcmp ("cleanup", whichhook))
 333     register_cleanup_hook = yesno;
 334   else
 335     return LDPS_ERR;
 336   return LDPS_OK;
 337 }
 338
 339 /* Determine type of plugin option and pass to individual parsers.  */
 340 static enum ld_plugin_status
 341 parse_option (const char *opt)
 342 {
 343   if (!strncmp ("fail", opt, 4))
 344     return set_ret_val (opt + 4, LDPS_ERR);
 345   else if (!strncmp ("pass", opt, 4))
 346     return set_ret_val (opt + 4, LDPS_OK);
 347   else if (!strncmp ("register", opt, 8))
 348     return set_register_hook (opt + 8, TRUE);
 349   else if (!strncmp ("noregister", opt, 10))
 350     return set_register_hook (opt + 10, FALSE);
 351   else if (!strncmp ("claim:", opt, 6))
 352     return record_claim_file (opt + 6);
 353   else if (!strncmp ("read:", opt, 5))
 354     return record_read_length (opt + 5);
 355   else if (!strncmp ("sym:", opt, 4))
 356     return record_claimed_file_symbol (opt + 4);
 357   else if (!strncmp ("add:", opt, 4))
 358     return record_add_file (opt + 4, ADD_FILE);
 359   else if (!strncmp ("lib:", opt, 4))
 360     return record_add_file (opt + 4, ADD_LIB);
 361   else if (!strncmp ("dir:", opt, 4))
 362     return record_add_file (opt + 4, ADD_DIR);
 363   else if (!strcmp ("dumpresolutions", opt))
 364     dumpresolutions = TRUE;
 365   else
 366     return LDPS_ERR;
 367   return LDPS_OK;
 368 }
 369
 370 /* Output contents of transfer vector array entry in human-readable form.  */
 371 static void
 372 dump_tv_tag (size_t n, struct ld_plugin_tv *tv)
 373 {
 374   size_t tag;
 375   char unknownbuf[40];
 376   const char *name;
 377
 378   for (tag = 0; tag < ARRAY_SIZE (tag_names); tag++)
 379     if (tag_names[tag].tag == tv->tv_tag)
 380       break;
 381   sprintf (unknownbuf, "unknown tag #%d", tv->tv_tag);
 382   name = (tag < ARRAY_SIZE (tag_names)) ? tag_names[tag].name : unknownbuf;
 383   switch (tv->tv_tag)
 384     {
 385       case LDPT_OPTION:
 386       case LDPT_OUTPUT_NAME:
 387         TV_MESSAGE (LDPL_INFO, "tv[%d]: %s '%s'", n, name,
 388                     tv->tv_u.tv_string);
 389         break;
 390       case LDPT_REGISTER_CLAIM_FILE_HOOK:
 391       case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 392       case LDPT_REGISTER_CLEANUP_HOOK:
 393       case LDPT_ADD_SYMBOLS:
 394       case LDPT_GET_SYMBOLS:
 395       case LDPT_GET_SYMBOLS_V2:
 396       case LDPT_ADD_INPUT_FILE:
 397       case LDPT_MESSAGE:
 398       case LDPT_GET_INPUT_FILE:
 399       case LDPT_GET_VIEW:
 400       case LDPT_RELEASE_INPUT_FILE:
 401       case LDPT_ADD_INPUT_LIBRARY:
 402       case LDPT_SET_EXTRA_LIBRARY_PATH:
 403         TV_MESSAGE (LDPL_INFO, "tv[%d]: %s func@0x%p", n, name,
 404                     (void *)(tv->tv_u.tv_message));
 405         break;
 406       case LDPT_NULL:
 407       case LDPT_API_VERSION:
 408       case LDPT_GOLD_VERSION:
 409       case LDPT_LINKER_OUTPUT:
 410       case LDPT_GNU_LD_VERSION:
 411       default:
 412         TV_MESSAGE (LDPL_INFO, "tv[%d]: %s value %W (%d)", n, name,
 413                     (bfd_vma)tv->tv_u.tv_val, tv->tv_u.tv_val);
 414         break;
 415     }
 416 }
 417
 418 /* Handle/record information received in a transfer vector entry.  */
 419 static enum ld_plugin_status
 420 parse_tv_tag (struct ld_plugin_tv *tv)
 421 {
 422 #define SETVAR(x) x = tv->tv_u.x
 423   switch (tv->tv_tag)
 424     {
 425       case LDPT_OPTION:
 426         return parse_option (tv->tv_u.tv_string);
 427       case LDPT_NULL:
 428       case LDPT_GOLD_VERSION:
 429       case LDPT_GNU_LD_VERSION:
 430       case LDPT_API_VERSION:
 431       default:
 432         break;
 433       case LDPT_OUTPUT_NAME:
 434         output_name = tv->tv_u.tv_string;
 435         break;
 436       case LDPT_LINKER_OUTPUT:
 437         linker_output = tv->tv_u.tv_val;
 438         break;
 439       case LDPT_REGISTER_CLAIM_FILE_HOOK:
 440         SETVAR(tv_register_claim_file);
 441         break;
 442       case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 443         SETVAR(tv_register_all_symbols_read);
 444         break;
 445       case LDPT_REGISTER_CLEANUP_HOOK:
 446         SETVAR(tv_register_cleanup);
 447         break;
 448       case LDPT_ADD_SYMBOLS:
 449         SETVAR(tv_add_symbols);
 450         break;
 451       case LDPT_GET_SYMBOLS:
 452         SETVAR(tv_get_symbols);
 453         break;
 454       case LDPT_GET_SYMBOLS_V2:
 455         tv_get_symbols_v2 = tv->tv_u.tv_get_symbols;
 456         break;
 457       case LDPT_ADD_INPUT_FILE:
 458         SETVAR(tv_add_input_file);
 459         break;
 460       case LDPT_MESSAGE:
 461         SETVAR(tv_message);
 462         break;
 463       case LDPT_GET_INPUT_FILE:
 464         SETVAR(tv_get_input_file);
 465         break;
 466       case LDPT_GET_VIEW:
 467         SETVAR(tv_get_view);
 468         break;
 469       case LDPT_RELEASE_INPUT_FILE:
 470         SETVAR(tv_release_input_file);
 471         break;
 472       case LDPT_ADD_INPUT_LIBRARY:
 473         SETVAR(tv_add_input_library);
 474         break;
 475       case LDPT_SET_EXTRA_LIBRARY_PATH:
 476         SETVAR(tv_set_extra_library_path);
 477         break;
 478     }
 479 #undef SETVAR
 480   return LDPS_OK;
 481 }
 482
 483 /* Record any useful information in transfer vector entry and display
 484    it in human-readable form using the plugin API message() callback.  */
 485 enum ld_plugin_status
 486 parse_and_dump_tv_tag (size_t n, struct ld_plugin_tv *tv)
 487 {
 488   enum ld_plugin_status rv = parse_tv_tag (tv);
 489   dump_tv_tag (n, tv);
 490   return rv;
 491 }
 492
 493 /* Standard plugin API entry point.  */
 494 enum ld_plugin_status
 495 onload (struct ld_plugin_tv *tv)
 496 {
 497   size_t n = 0;
 498   enum ld_plugin_status rv;
 499
 500   /* This plugin does nothing but dump the tv array.  It would
 501      be an error if this function was called without one.  */
 502   if (!tv)
 503     return LDPS_ERR;
 504
 505   /* First entry should always be LDPT_MESSAGE, letting us get
 506      hold of it easily so we can send output straight away.  */
 507   if (tv[0].tv_tag == LDPT_MESSAGE)
 508     tv_message = tv[0].tv_u.tv_message;
 509
 510   fflush (NULL);
 511   TV_MESSAGE (LDPL_INFO, "Hello from testplugin.");
 512
 513   do
 514     if ((rv = parse_and_dump_tv_tag (n++, tv)) != LDPS_OK)
 515       return rv;
 516   while ((tv++)->tv_tag != LDPT_NULL);
 517
 518   /* Register hooks only if instructed by options.  */
 519   if (register_claimfile_hook)
 520     {
 521       if (!tv_register_claim_file)
 522         {
 523           TV_MESSAGE (LDPL_FATAL, "No register_claim_file hook");
 524           fflush (NULL);
 525           return LDPS_ERR;
 526         }
 527       (*tv_register_claim_file) (onclaim_file);
 528     }
 529   if (register_allsymbolsread_hook)
 530     {
 531       if (!tv_register_all_symbols_read)
 532         {
 533           TV_MESSAGE (LDPL_FATAL, "No register_all_symbols_read hook");
 534           fflush (NULL);
 535           return LDPS_ERR;
 536         }
 537       (*tv_register_all_symbols_read) (onall_symbols_read);
 538     }
 539   if (register_cleanup_hook)
 540     {
 541       if (!tv_register_cleanup)
 542         {
 543           TV_MESSAGE (LDPL_FATAL, "No register_cleanup hook");
 544           fflush (NULL);
 545           return LDPS_ERR;
 546         }
 547       (*tv_register_cleanup) (oncleanup);
 548     }
 549   fflush (NULL);
 550   return onload_ret;
 551 }
 552
 553 /* Standard plugin API registerable hook.  */
 554 static enum ld_plugin_status
 555 onclaim_file (const struct ld_plugin_input_file *file, int *claimed)
 556 {
 557   /* Possible read of some bytes out of the input file into a buffer.  This
 558      simulates a plugin that reads some file content in order to decide if
 559      the file should be claimed or not.  */
 560   if (bytes_to_read_before_claim > 0)
 561     {
 562       char *buffer = malloc (bytes_to_read_before_claim);
 563
 564       if (buffer == NULL)
 565         return LDPS_ERR;
 566       if (read (file->fd, buffer, bytes_to_read_before_claim) < 0)
 567         return LDPS_ERR;
 568       free (buffer);
 569     }
 570
 571   /* Let's see if we want to claim this file.  */
 572   claim_file_t *claimfile = claimfiles_list;
 573   while (claimfile)
 574     {
 575       if (!strcmp (file->name, claimfile->file.name))
 576         break;
 577       claimfile = claimfile->next;
 578     }
 579
 580   /* Inform the user/testsuite.  */
 581   TV_MESSAGE (LDPL_INFO, "hook called: claim_file %s [@%ld/%ld] %s",
 582               file->name, (long)file->offset, (long)file->filesize,
 583               claimfile ? "CLAIMED" : "not claimed");
 584   fflush (NULL);
 585
 586   /* If we decided to claim it, record that fact, and add any symbols
 587      that were defined for it by plugin options.  */
 588   *claimed = (claimfile != 0);
 589   if (claimfile)
 590     {
 591       claimfile->claimed = TRUE;
 592       claimfile->file = *file;
 593       if (claimfile->n_syms_used && !tv_add_symbols)
 594         return LDPS_ERR;
 595       else if (claimfile->n_syms_used)
 596         return (*tv_add_symbols) (claimfile->file.handle,
 597                                 claimfile->n_syms_used, claimfile->symbols);
 598     }
 599
 600   return claim_file_ret;
 601 }
 602
 603 /* Standard plugin API registerable hook.  */
 604 static enum ld_plugin_status
 605 onall_symbols_read (void)
 606 {
 607   static const char *resolutions[] =
 608     {
 609       "LDPR_UNKNOWN",
 610       "LDPR_UNDEF",
 611       "LDPR_PREVAILING_DEF",
 612       "LDPR_PREVAILING_DEF_IRONLY",
 613       "LDPR_PREEMPTED_REG",
 614       "LDPR_PREEMPTED_IR",
 615       "LDPR_RESOLVED_IR",
 616       "LDPR_RESOLVED_EXEC",
 617       "LDPR_RESOLVED_DYN",
 618       "LDPR_PREVAILING_DEF_IRONLY_EXP",
 619     };
 620   claim_file_t *claimfile = dumpresolutions ? claimfiles_list : NULL;
 621   add_file_t *addfile = addfiles_list;
 622   TV_MESSAGE (LDPL_INFO, "hook called: all symbols read.");
 623   for ( ; claimfile; claimfile = claimfile->next)
 624     {
 625       enum ld_plugin_status rv;
 626       int n;
 627       if (claimfile->n_syms_used && !tv_get_symbols_v2)
 628         return LDPS_ERR;
 629       else if (!claimfile->n_syms_used)
 630         continue;
 631       rv = tv_get_symbols_v2 (claimfile->file.handle, claimfile->n_syms_used,
 632                               claimfile->symbols);
 633       if (rv != LDPS_OK)
 634         return rv;
 635       for (n = 0; n < claimfile->n_syms_used; n++)
 636         TV_MESSAGE (LDPL_INFO, "Sym: '%s%s%s' Resolution: %s",
 637                     claimfile->symbols[n].name,
 638                     claimfile->symbols[n].version ? "@" : "",
 639                     (claimfile->symbols[n].version
 640                      ? claimfile->symbols[n].version : ""),
 641                     resolutions[claimfile->symbols[n].resolution]);
 642     }
 643   for ( ; addfile ; addfile = addfile->next)
 644     {
 645       enum ld_plugin_status rv;
 646       if (addfile->type == ADD_LIB && tv_add_input_library)
 647         rv = (*tv_add_input_library) (addfile->name);
 648       else if (addfile->type == ADD_FILE && tv_add_input_file)
 649         rv = (*tv_add_input_file) (addfile->name);
 650       else if (addfile->type == ADD_DIR && tv_set_extra_library_path)
 651         rv = (*tv_set_extra_library_path) (addfile->name);
 652       else
 653         rv = LDPS_ERR;
 654       if (rv != LDPS_OK)
 655         return rv;
 656     }
 657   fflush (NULL);
 658   return all_symbols_read_ret;
 659 }
 660
 661 /* Standard plugin API registerable hook.  */
 662 static enum ld_plugin_status
 663 oncleanup (void)
 664 {
 665   TV_MESSAGE (LDPL_INFO, "hook called: cleanup.");
 666   fflush (NULL);
 667   return cleanup_ret;
 668 }