ld/testplug2.c

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