Retro68/binutils/gold/testsuite/plugin_test.c
2018-12-28 16:25:28 +01:00

710 lines
19 KiB
C

/* test_plugin.c -- simple linker plugin test
Copyright (C) 2008-2018 Free Software Foundation, Inc.
Written by Cary Coutant <ccoutant@google.com>.
This file is part of gold.
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. */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "plugin-api.h"
struct claimed_file
{
const char* name;
void* handle;
int nsyms;
struct ld_plugin_symbol* syms;
struct claimed_file* next;
};
struct sym_info
{
int size;
char* type;
char* bind;
char* vis;
char* sect;
char* name;
char* ver;
};
static struct claimed_file* first_claimed_file = NULL;
static struct claimed_file* last_claimed_file = NULL;
static ld_plugin_register_claim_file register_claim_file_hook = NULL;
static ld_plugin_register_all_symbols_read register_all_symbols_read_hook = NULL;
static ld_plugin_register_cleanup register_cleanup_hook = NULL;
static ld_plugin_add_symbols add_symbols = NULL;
static ld_plugin_get_symbols get_symbols = NULL;
static ld_plugin_get_symbols get_symbols_v2 = NULL;
static ld_plugin_get_symbols get_symbols_v3 = NULL;
static ld_plugin_add_input_file add_input_file = NULL;
static ld_plugin_message message = NULL;
static ld_plugin_get_input_file get_input_file = NULL;
static ld_plugin_release_input_file release_input_file = NULL;
static ld_plugin_get_input_section_count get_input_section_count = NULL;
static ld_plugin_get_input_section_type get_input_section_type = NULL;
static ld_plugin_get_input_section_name get_input_section_name = NULL;
static ld_plugin_get_input_section_contents get_input_section_contents = NULL;
static ld_plugin_update_section_order update_section_order = NULL;
static ld_plugin_allow_section_ordering allow_section_ordering = NULL;
static ld_plugin_get_wrap_symbols get_wrap_symbols = NULL;
#define MAXOPTS 10
static const char *opts[MAXOPTS];
static int nopts = 0;
enum ld_plugin_status onload(struct ld_plugin_tv *tv);
enum ld_plugin_status claim_file_hook(const struct ld_plugin_input_file *file,
int *claimed);
enum ld_plugin_status all_symbols_read_hook(void);
enum ld_plugin_status cleanup_hook(void);
static void parse_readelf_line(char*, struct sym_info*);
enum ld_plugin_status
onload(struct ld_plugin_tv *tv)
{
struct ld_plugin_tv *entry;
int api_version = 0;
int gold_version = 0;
int i;
for (entry = tv; entry->tv_tag != LDPT_NULL; ++entry)
{
switch (entry->tv_tag)
{
case LDPT_API_VERSION:
api_version = entry->tv_u.tv_val;
break;
case LDPT_GOLD_VERSION:
gold_version = entry->tv_u.tv_val;
break;
case LDPT_LINKER_OUTPUT:
break;
case LDPT_OPTION:
if (nopts < MAXOPTS)
opts[nopts++] = entry->tv_u.tv_string;
break;
case LDPT_REGISTER_CLAIM_FILE_HOOK:
register_claim_file_hook = entry->tv_u.tv_register_claim_file;
break;
case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
register_all_symbols_read_hook =
entry->tv_u.tv_register_all_symbols_read;
break;
case LDPT_REGISTER_CLEANUP_HOOK:
register_cleanup_hook = entry->tv_u.tv_register_cleanup;
break;
case LDPT_ADD_SYMBOLS:
add_symbols = entry->tv_u.tv_add_symbols;
break;
case LDPT_GET_SYMBOLS:
get_symbols = entry->tv_u.tv_get_symbols;
break;
case LDPT_GET_SYMBOLS_V2:
get_symbols_v2 = entry->tv_u.tv_get_symbols;
break;
case LDPT_GET_SYMBOLS_V3:
get_symbols_v3 = entry->tv_u.tv_get_symbols;
break;
case LDPT_ADD_INPUT_FILE:
add_input_file = entry->tv_u.tv_add_input_file;
break;
case LDPT_MESSAGE:
message = entry->tv_u.tv_message;
break;
case LDPT_GET_INPUT_FILE:
get_input_file = entry->tv_u.tv_get_input_file;
break;
case LDPT_RELEASE_INPUT_FILE:
release_input_file = entry->tv_u.tv_release_input_file;
break;
case LDPT_GET_INPUT_SECTION_COUNT:
get_input_section_count = *entry->tv_u.tv_get_input_section_count;
break;
case LDPT_GET_INPUT_SECTION_TYPE:
get_input_section_type = *entry->tv_u.tv_get_input_section_type;
break;
case LDPT_GET_INPUT_SECTION_NAME:
get_input_section_name = *entry->tv_u.tv_get_input_section_name;
break;
case LDPT_GET_INPUT_SECTION_CONTENTS:
get_input_section_contents = *entry->tv_u.tv_get_input_section_contents;
break;
case LDPT_UPDATE_SECTION_ORDER:
update_section_order = *entry->tv_u.tv_update_section_order;
break;
case LDPT_ALLOW_SECTION_ORDERING:
allow_section_ordering = *entry->tv_u.tv_allow_section_ordering;
break;
case LDPT_GET_WRAP_SYMBOLS:
get_wrap_symbols = *entry->tv_u.tv_get_wrap_symbols;
break;
default:
break;
}
}
if (message == NULL)
{
fprintf(stderr, "tv_message interface missing\n");
return LDPS_ERR;
}
if (register_claim_file_hook == NULL)
{
fprintf(stderr, "tv_register_claim_file_hook interface missing\n");
return LDPS_ERR;
}
if (register_all_symbols_read_hook == NULL)
{
fprintf(stderr, "tv_register_all_symbols_read_hook interface missing\n");
return LDPS_ERR;
}
if (register_cleanup_hook == NULL)
{
fprintf(stderr, "tv_register_cleanup_hook interface missing\n");
return LDPS_ERR;
}
(*message)(LDPL_INFO, "API version: %d", api_version);
(*message)(LDPL_INFO, "gold version: %d", gold_version);
for (i = 0; i < nopts; ++i)
(*message)(LDPL_INFO, "option: %s", opts[i]);
if ((*register_claim_file_hook)(claim_file_hook) != LDPS_OK)
{
(*message)(LDPL_ERROR, "error registering claim file hook");
return LDPS_ERR;
}
if ((*register_all_symbols_read_hook)(all_symbols_read_hook) != LDPS_OK)
{
(*message)(LDPL_ERROR, "error registering all symbols read hook");
return LDPS_ERR;
}
if ((*register_cleanup_hook)(cleanup_hook) != LDPS_OK)
{
(*message)(LDPL_ERROR, "error registering cleanup hook");
return LDPS_ERR;
}
if (get_input_section_count == NULL)
{
fprintf(stderr, "tv_get_input_section_count interface missing\n");
return LDPS_ERR;
}
if (get_input_section_type == NULL)
{
fprintf(stderr, "tv_get_input_section_type interface missing\n");
return LDPS_ERR;
}
if (get_input_section_name == NULL)
{
fprintf(stderr, "tv_get_input_section_name interface missing\n");
return LDPS_ERR;
}
if (get_input_section_contents == NULL)
{
fprintf(stderr, "tv_get_input_section_contents interface missing\n");
return LDPS_ERR;
}
if (update_section_order == NULL)
{
fprintf(stderr, "tv_update_section_order interface missing\n");
return LDPS_ERR;
}
if (allow_section_ordering == NULL)
{
fprintf(stderr, "tv_allow_section_ordering interface missing\n");
return LDPS_ERR;
}
if (get_wrap_symbols == NULL)
{
fprintf(stderr, "tv_get_wrap_symbols interface missing\n");
return LDPS_ERR;
}
else
{
const char **wrap_symbols;
uint64_t count = 0;
if (get_wrap_symbols(&count, &wrap_symbols) == LDPS_OK)
{
(*message)(LDPL_INFO, "Number of wrap symbols = %lu", count);
for (; count > 0; --count)
(*message)(LDPL_INFO, "Wrap symbol %s", wrap_symbols[count - 1]);
}
else
{
fprintf(stderr, "tv_get_wrap_symbols interface call failed\n");
return LDPS_ERR;
}
}
return LDPS_OK;
}
enum ld_plugin_status
claim_file_hook (const struct ld_plugin_input_file* file, int* claimed)
{
int len;
off_t end_offset;
char buf[160];
struct claimed_file* claimed_file;
struct ld_plugin_symbol* syms;
int nsyms = 0;
int maxsyms = 0;
FILE* irfile;
struct sym_info info;
int weak;
int def;
int vis;
int is_comdat;
int i;
int irfile_was_opened = 0;
char syms_name[80];
(*message)(LDPL_INFO,
"%s: claim file hook called (offset = %ld, size = %ld)",
file->name, (long)file->offset, (long)file->filesize);
/* Look for matching syms file for an archive member. */
if (file->offset == 0)
snprintf(syms_name, sizeof(syms_name), "%s.syms", file->name);
else
snprintf(syms_name, sizeof(syms_name), "%s-%d.syms",
file->name, (int)file->offset);
irfile = fopen(syms_name, "r");
if (irfile != NULL)
{
irfile_was_opened = 1;
end_offset = 1 << 20;
}
/* Otherwise, see if the file itself is a syms file. */
if (!irfile_was_opened)
{
irfile = fdopen(file->fd, "r");
(void)fseek(irfile, file->offset, SEEK_SET);
end_offset = file->offset + file->filesize;
}
/* Look for the beginning of output from readelf -s. */
len = fread(buf, 1, 13, irfile);
if (len < 13 || strncmp(buf, "\nSymbol table", 13) != 0)
return LDPS_OK;
/* Skip the two header lines. */
(void) fgets(buf, sizeof(buf), irfile);
(void) fgets(buf, sizeof(buf), irfile);
if (add_symbols == NULL)
{
fprintf(stderr, "tv_add_symbols interface missing\n");
return LDPS_ERR;
}
/* Parse the output from readelf. The columns are:
Index Value Size Type Binding Visibility Section Name. */
syms = (struct ld_plugin_symbol*)malloc(sizeof(struct ld_plugin_symbol) * 8);
if (syms == NULL)
return LDPS_ERR;
maxsyms = 8;
while (ftell(irfile) < end_offset
&& fgets(buf, sizeof(buf), irfile) != NULL)
{
parse_readelf_line(buf, &info);
/* Ignore local symbols. */
if (strncmp(info.bind, "LOCAL", 5) == 0)
continue;
weak = strncmp(info.bind, "WEAK", 4) == 0;
if (strncmp(info.sect, "UND", 3) == 0)
def = weak ? LDPK_WEAKUNDEF : LDPK_UNDEF;
else if (strncmp(info.sect, "COM", 3) == 0)
def = LDPK_COMMON;
else
def = weak ? LDPK_WEAKDEF : LDPK_DEF;
if (strncmp(info.vis, "INTERNAL", 8) == 0)
vis = LDPV_INTERNAL;
else if (strncmp(info.vis, "HIDDEN", 6) == 0)
vis = LDPV_HIDDEN;
else if (strncmp(info.vis, "PROTECTED", 9) == 0)
vis = LDPV_PROTECTED;
else
vis = LDPV_DEFAULT;
/* If the symbol is listed in the options list, special-case
it as a comdat symbol. */
is_comdat = 0;
for (i = 0; i < nopts; ++i)
{
if (info.name != NULL && strcmp(info.name, opts[i]) == 0)
{
is_comdat = 1;
break;
}
}
if (nsyms >= maxsyms)
{
syms = (struct ld_plugin_symbol*)
realloc(syms, sizeof(struct ld_plugin_symbol) * maxsyms * 2);
if (syms == NULL)
return LDPS_ERR;
maxsyms *= 2;
}
if (info.name == NULL)
syms[nsyms].name = NULL;
else
{
len = strlen(info.name);
syms[nsyms].name = malloc(len + 1);
strncpy(syms[nsyms].name, info.name, len + 1);
}
if (info.ver == NULL)
syms[nsyms].version = NULL;
else
{
len = strlen(info.ver);
syms[nsyms].version = malloc(len + 1);
strncpy(syms[nsyms].version, info.ver, len + 1);
}
syms[nsyms].def = def;
syms[nsyms].visibility = vis;
syms[nsyms].size = info.size;
syms[nsyms].comdat_key = is_comdat ? syms[nsyms].name : NULL;
syms[nsyms].resolution = LDPR_UNKNOWN;
++nsyms;
}
claimed_file = (struct claimed_file*) malloc(sizeof(struct claimed_file));
if (claimed_file == NULL)
return LDPS_ERR;
claimed_file->name = file->name;
claimed_file->handle = file->handle;
claimed_file->nsyms = nsyms;
claimed_file->syms = syms;
claimed_file->next = NULL;
if (last_claimed_file == NULL)
first_claimed_file = claimed_file;
else
last_claimed_file->next = claimed_file;
last_claimed_file = claimed_file;
(*message)(LDPL_INFO, "%s: claiming file, adding %d symbols",
file->name, nsyms);
if (nsyms > 0)
(*add_symbols)(file->handle, nsyms, syms);
*claimed = 1;
if (irfile_was_opened)
fclose(irfile);
return LDPS_OK;
}
enum ld_plugin_status
all_symbols_read_hook(void)
{
int i;
const char* res;
struct claimed_file* claimed_file;
struct ld_plugin_input_file file;
FILE* irfile;
off_t end_offset;
struct sym_info info;
int len;
char buf[160];
char* p;
const char* filename;
(*message)(LDPL_INFO, "all symbols read hook called");
if (get_symbols_v3 == NULL)
{
fprintf(stderr, "tv_get_symbols (v3) interface missing\n");
return LDPS_ERR;
}
for (claimed_file = first_claimed_file;
claimed_file != NULL;
claimed_file = claimed_file->next)
{
enum ld_plugin_status status = (*get_symbols_v3)(
claimed_file->handle, claimed_file->nsyms, claimed_file->syms);
if (status == LDPS_NO_SYMS)
{
(*message)(LDPL_INFO, "%s: no symbols", claimed_file->name);
continue;
}
for (i = 0; i < claimed_file->nsyms; ++i)
{
switch (claimed_file->syms[i].resolution)
{
case LDPR_UNKNOWN:
res = "UNKNOWN";
break;
case LDPR_UNDEF:
res = "UNDEF";
break;
case LDPR_PREVAILING_DEF:
res = "PREVAILING_DEF_REG";
break;
case LDPR_PREVAILING_DEF_IRONLY:
res = "PREVAILING_DEF_IRONLY";
break;
case LDPR_PREVAILING_DEF_IRONLY_EXP:
res = "PREVAILING_DEF_IRONLY_EXP";
break;
case LDPR_PREEMPTED_REG:
res = "PREEMPTED_REG";
break;
case LDPR_PREEMPTED_IR:
res = "PREEMPTED_IR";
break;
case LDPR_RESOLVED_IR:
res = "RESOLVED_IR";
break;
case LDPR_RESOLVED_EXEC:
res = "RESOLVED_EXEC";
break;
case LDPR_RESOLVED_DYN:
res = "RESOLVED_DYN";
break;
default:
res = "?";
break;
}
(*message)(LDPL_INFO, "%s: %s: %s", claimed_file->name,
claimed_file->syms[i].name, res);
}
}
if (add_input_file == NULL)
{
fprintf(stderr, "tv_add_input_file interface missing\n");
return LDPS_ERR;
}
if (get_input_file == NULL)
{
fprintf(stderr, "tv_get_input_file interface missing\n");
return LDPS_ERR;
}
if (release_input_file == NULL)
{
fprintf(stderr, "tv_release_input_file interface missing\n");
return LDPS_ERR;
}
for (claimed_file = first_claimed_file;
claimed_file != NULL;
claimed_file = claimed_file->next)
{
int irfile_was_opened = 0;
char syms_name[80];
(*get_input_file) (claimed_file->handle, &file);
if (file.offset == 0)
snprintf(syms_name, sizeof(syms_name), "%s.syms", file.name);
else
snprintf(syms_name, sizeof(syms_name), "%s-%d.syms",
file.name, (int)file.offset);
irfile = fopen(syms_name, "r");
if (irfile != NULL)
{
irfile_was_opened = 1;
end_offset = 1 << 20;
}
if (!irfile_was_opened)
{
irfile = fdopen(file.fd, "r");
(void)fseek(irfile, file.offset, SEEK_SET);
end_offset = file.offset + file.filesize;
}
/* Look for the beginning of output from readelf -s. */
len = fread(buf, 1, 13, irfile);
if (len < 13 || strncmp(buf, "\nSymbol table", 13) != 0)
{
fprintf(stderr, "%s: can't re-read original input file\n",
claimed_file->name);
return LDPS_ERR;
}
/* Skip the two header lines. */
(void) fgets(buf, sizeof(buf), irfile);
(void) fgets(buf, sizeof(buf), irfile);
filename = NULL;
while (ftell(irfile) < end_offset
&& fgets(buf, sizeof(buf), irfile) != NULL)
{
parse_readelf_line(buf, &info);
/* Look for file name. */
if (strncmp(info.type, "FILE", 4) == 0)
{
len = strlen(info.name);
p = malloc(len + 1);
strncpy(p, info.name, len + 1);
filename = p;
break;
}
}
if (irfile_was_opened)
fclose(irfile);
(*release_input_file) (claimed_file->handle);
if (filename == NULL)
filename = claimed_file->name;
if (claimed_file->nsyms == 0)
continue;
if (strlen(filename) >= sizeof(buf))
{
(*message)(LDPL_FATAL, "%s: filename too long", filename);
return LDPS_ERR;
}
strcpy(buf, filename);
p = strrchr(buf, '.');
if (p == NULL
|| (strcmp(p, ".syms") != 0
&& strcmp(p, ".c") != 0
&& strcmp(p, ".cc") != 0))
{
(*message)(LDPL_FATAL, "%s: filename has unknown suffix",
filename);
return LDPS_ERR;
}
p[1] = 'o';
p[2] = '\0';
(*message)(LDPL_INFO, "%s: adding new input file", buf);
(*add_input_file)(buf);
}
return LDPS_OK;
}
enum ld_plugin_status
cleanup_hook(void)
{
(*message)(LDPL_INFO, "cleanup hook called");
return LDPS_OK;
}
static void
parse_readelf_line(char* p, struct sym_info* info)
{
int len;
p += strspn(p, " ");
/* Index field. */
p += strcspn(p, " ");
p += strspn(p, " ");
/* Value field. */
p += strcspn(p, " ");
p += strspn(p, " ");
/* Size field. */
info->size = atoi(p);
p += strcspn(p, " ");
p += strspn(p, " ");
/* Type field. */
info->type = p;
p += strcspn(p, " ");
p += strspn(p, " ");
/* Binding field. */
info->bind = p;
p += strcspn(p, " ");
p += strspn(p, " ");
/* Visibility field. */
info->vis = p;
p += strcspn(p, " ");
p += strspn(p, " ");
if (*p == '[')
{
/* Skip st_other. */
p += strcspn(p, "]");
p += strspn(p, "] ");
}
/* Section field. */
info->sect = p;
p += strcspn(p, " ");
p += strspn(p, " ");
/* Name field. */
len = strcspn(p, "@\n");
if (len > 0 && p[len] == '@')
{
/* Get the symbol version. */
char* vp = p + len;
int vlen;
vp += strspn(vp, "@");
vlen = strcspn(vp, "\n");
vp[vlen] = '\0';
if (vlen > 0)
info->ver = vp;
else
info->ver = NULL;
}
else
info->ver = NULL;
p[len] = '\0';
if (len > 0)
info->name = p;
else
info->name = NULL;
}