#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
-#include <ar.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
char *name;
void *handle;
struct plugin_symtab symtab;
- unsigned char temp;
};
-static char *temp_obj_dir_name;
+static char *arguments_file_name;
static ld_plugin_register_claim_file register_claim_file;
static ld_plugin_add_symbols add_symbols;
static ld_plugin_register_all_symbols_read register_all_symbols_read;
static ld_plugin_register_cleanup register_cleanup;
static ld_plugin_add_input_file add_input_file;
static ld_plugin_add_input_library add_input_library;
+static ld_plugin_message message;
static struct plugin_file_info *claimed_files = NULL;
static unsigned int num_claimed_files = 0;
static bool nop;
static char *resolution_file = NULL;
+static void
+check (bool gate, enum ld_plugin_level level, const char *text)
+{
+ if (gate)
+ return;
+
+ if (message)
+ message (level, text);
+ else
+ {
+ /* If there is no nicer way to inform the user, fallback to stderr. */
+ fprintf (stderr, "%s\n", text);
+ if (level == LDPL_FATAL)
+ abort ();
+ }
+}
+
/* Parse an entry of the IL symbol table. The data to be parsed is pointed
by P and the result is written in ENTRY. The slot number is stored in SLOT.
Returns the address of the next entry. */
LDPV_HIDDEN
};
- entry->name = strdup (p);
+ entry->name = xstrdup (p);
while (*p)
p++;
p++;
if (strlen (entry->comdat_key) == 0)
entry->comdat_key = NULL;
else
- entry->comdat_key = strdup (entry->comdat_key);
+ entry->comdat_key = xstrdup (entry->comdat_key);
t = *p;
- assert (t <= 4);
+ check (t <= 4, LDPL_FATAL, "invalid symbol kind found");
entry->def = translate_kind[t];
p++;
t = *p;
- assert (t <= 3);
+ check (t <= 3, LDPL_FATAL, "invalid symbol visibility found");
entry->visibility = translate_visibility[t];
p++;
while (data < end)
{
n++;
- syms = realloc (syms, n * sizeof (struct ld_plugin_symbol));
- assert (syms);
- slots = realloc (slots, n * sizeof (uint32_t));
- assert (slots);
+ syms = xrealloc (syms, n * sizeof (struct ld_plugin_symbol));
+ check (syms, LDPL_FATAL, "could not allocate memory");
+ slots = xrealloc (slots, n * sizeof (uint32_t));
+ check (slots, LDPL_FATAL, "could not allocate memory");
data = parse_table_entry (data, &syms[n - 1], &slots[n - 1]);
}
claimed_files = NULL;
num_claimed_files = 0;
- free (temp_obj_dir_name);
- temp_obj_dir_name = NULL;
-
- if (resolution_file)
- {
- free (resolution_file);
- resolution_file = NULL;
- }
+ if (arguments_file_name)
+ free (arguments_file_name);
+ arguments_file_name = NULL;
}
/* Writes the relocations to disk. */
unsigned int i;
FILE *f;
- if (!resolution_file)
- return;
-
+ check (resolution_file, LDPL_FATAL, "resolution file not specified");
f = fopen (resolution_file, "w");
- assert (f);
+ check (f, LDPL_FATAL, "could not open file");
fprintf (f, "%d\n", num_claimed_files);
struct ld_plugin_symbol *syms = symtab->syms;
unsigned j;
- assert (syms);
get_symbols (info->handle, symtab->nsyms, syms);
fprintf (f, "%s %d\n", info->name, info->symtab.nsyms);
{
uint32_t slot = symtab->slots[j];
unsigned int resolution = syms[j].resolution;
- fprintf (f, "%d %s\n", slot, lto_resolution_str[resolution]);
+ fprintf (f, "%d %s %s\n", slot, lto_resolution_str[resolution], syms[j].name);
}
}
fclose (f);
static void
add_output_files (FILE *f)
{
- char fname[1000]; /* FIXME: Is this big enough? */
-
for (;;)
{
+ const unsigned piece = 32;
+ char *buf, *s = xmalloc (piece);
size_t len;
- char *s = fgets (fname, sizeof (fname), f);
- if (!s)
- break;
+ buf = s;
+cont:
+ if (!fgets (buf, piece, f))
+ break;
len = strlen (s);
- assert (s[len - 1] == '\n');
+ if (s[len - 1] != '\n')
+ {
+ s = xrealloc (s, len + piece);
+ buf = s + len;
+ goto cont;
+ }
s[len - 1] = '\0';
num_output_files++;
- output_files = realloc (output_files, num_output_files * sizeof (char *));
- output_files[num_output_files - 1] = strdup (s);
+ output_files
+ = xrealloc (output_files, num_output_files * sizeof (char *));
+ output_files[num_output_files - 1] = s;
add_input_file (output_files[num_output_files - 1]);
}
}
static void
exec_lto_wrapper (char *argv[])
{
- int t;
+ int t, i;
int status;
char *at_args;
- char *args_name;
FILE *args;
FILE *wrapper_output;
char *new_argv[3];
const char *errmsg;
/* Write argv to a file to avoid a command line that is too long. */
- t = asprintf (&at_args, "@%s/arguments", temp_obj_dir_name);
- assert (t >= 0);
+ arguments_file_name = make_temp_file ("");
+ check (arguments_file_name, LDPL_FATAL,
+ "Failed to generate a temorary file name");
- args_name = at_args + 1;
- args = fopen (args_name, "w");
- assert (args);
+ args = fopen (arguments_file_name, "w");
+ check (args, LDPL_FATAL, "could not open arguments file");
t = writeargv (&argv[1], args);
- assert (t == 0);
+ check (t == 0, LDPL_FATAL, "could not write arguments");
t = fclose (args);
- assert (t == 0);
+ check (t == 0, LDPL_FATAL, "could not close arguments file");
+
+ at_args = concat ("@", arguments_file_name, NULL);
+ check (at_args, LDPL_FATAL, "could not allocate");
+
+ for (i = 1; argv[i]; i++)
+ {
+ char *a = argv[i];
+ if (a[0] == '-' && a[1] == 'v' && a[2] == '\0')
+ {
+ for (i = 0; argv[i]; i++)
+ fprintf (stderr, "%s ", argv[i]);
+ fprintf (stderr, "\n");
+ break;
+ }
+ }
new_argv[0] = argv[0];
new_argv[1] = at_args;
if (debug)
{
- int i;
for (i = 0; new_argv[i]; i++)
fprintf (stderr, "%s ", new_argv[i]);
fprintf (stderr, "\n");
pex = pex_init (PEX_USE_PIPES, "lto-wrapper", NULL);
- assert (pex != NULL);
+ check (pex != NULL, LDPL_FATAL, "could not pex_init lto-wrapper");
errmsg = pex_run (pex, 0, new_argv[0], new_argv, NULL, NULL, &t);
- assert (errmsg == NULL);
- assert (t == 0);
+ check (errmsg == NULL, LDPL_FATAL, "could not run lto-wrapper");
+ check (t == 0, LDPL_FATAL, "could not run lto-wrapper");
wrapper_output = pex_read_output (pex, 0);
- assert (wrapper_output);
+ check (wrapper_output, LDPL_FATAL, "could not read lto-wrapper output");
add_output_files (wrapper_output);
t = pex_get_status (pex, 1, &status);
- assert (t == 1);
- assert (WIFEXITED (status) && WEXITSTATUS (status) == 0);
+ check (t == 1, LDPL_FATAL, "could not get lto-wrapper exit status");
+ check (WIFEXITED (status) && WEXITSTATUS (status) == 0, LDPL_FATAL,
+ "lto-wrapper failed");
pex_free (pex);
- t = unlink (args_name);
- assert (t == 0);
free (at_args);
}
return LDPS_OK;
}
- lto_argv = (char **) calloc (sizeof (char *), num_lto_args);
+ lto_argv = (char **) xcalloc (sizeof (char *), num_lto_args);
lto_arg_ptr = (const char **) lto_argv;
assert (lto_wrapper_argv);
static enum ld_plugin_status
cleanup_handler (void)
{
+ unsigned int i;
int t;
- unsigned i;
- for (i = 0; i < num_claimed_files; i++)
+ if (debug)
+ return LDPS_OK;
+
+ if (arguments_file_name)
{
- struct plugin_file_info *info = &claimed_files[i];
- if (info->temp)
- {
- t = unlink (info->name);
- assert (t == 0);
- }
+ t = unlink (arguments_file_name);
+ check (t == 0, LDPL_FATAL, "could not unlink arguments file");
+ }
+
+ for (i = 0; i < num_output_files; i++)
+ {
+ t = unlink (output_files[i]);
+ check (t == 0, LDPL_FATAL, "could not unlink output file");
}
- t = rmdir (temp_obj_dir_name);
- assert (t == 0);
free_2 ();
return LDPS_OK;
Elf *elf;
struct plugin_file_info lto_file;
Elf_Data *symtab;
- int lto_file_fd;
if (file->offset != 0)
{
- /* FIXME lto: lto1 should know how to handle archives. */
- int fd;
- off_t size = file->filesize;
- off_t offset;
-
- static int objnum = 0;
char *objname;
- int t = asprintf (&objname, "%s/obj%d.o",
- temp_obj_dir_name, objnum);
- assert (t >= 0);
- objnum++;
-
- fd = open (objname, O_RDWR | O_CREAT, 0666);
- assert (fd > 0);
- offset = lseek (file->fd, file->offset, SEEK_SET);
- assert (offset == file->offset);
- while (size > 0)
- {
- ssize_t r, written;
- char buf[1000];
- off_t s = sizeof (buf) < size ? sizeof (buf) : size;
- r = read (file->fd, buf, s);
- written = write (fd, buf, r);
- assert (written = r);
- size -= r;
- }
+ Elf *archive;
+ off_t offset;
+ /* We pass the offset of the actual file, not the archive header. */
+ int t = asprintf (&objname, "%s@0x%" PRIx64, file->name,
+ (int64_t) file->offset);
+ check (t >= 0, LDPL_FATAL, "asprintf failed");
lto_file.name = objname;
- lto_file_fd = fd;
- lto_file.handle = file->handle;
- lto_file.temp = 1;
+
+ archive = elf_begin (file->fd, ELF_C_READ, NULL);
+ check (elf_kind (archive) == ELF_K_AR, LDPL_FATAL,
+ "Not an archive and offset not 0");
+
+ /* elf_rand expects the offset to point to the ar header, not the
+ object itself. Subtract the size of the ar header (60 bytes).
+ We don't uses sizeof (struct ar_hd) to avoid including ar.h */
+
+ offset = file->offset - 60;
+ check (offset == elf_rand (archive, offset), LDPL_FATAL,
+ "could not seek in archive");
+ elf = elf_begin (file->fd, ELF_C_READ, archive);
+ check (elf != NULL, LDPL_FATAL, "could not find archive member");
+ elf_end (archive);
}
else
{
- lto_file.name = strdup (file->name);
- lto_file_fd = file->fd;
- lto_file.handle = file->handle;
- lto_file.temp = 0;
+ lto_file.name = xstrdup (file->name);
+ elf = elf_begin (file->fd, ELF_C_READ, NULL);
}
- elf = elf_begin (lto_file_fd, ELF_C_READ, NULL);
+ lto_file.handle = file->handle;
*claimed = 0;
status = add_symbols (file->handle, lto_file.symtab.nsyms,
lto_file.symtab.syms);
- assert (status == LDPS_OK);
+ check (status == LDPS_OK, LDPL_FATAL, "could not add symbols");
*claimed = 1;
num_claimed_files++;
claimed_files =
- realloc (claimed_files,
- num_claimed_files * sizeof (struct plugin_file_info));
+ xrealloc (claimed_files,
+ num_claimed_files * sizeof (struct plugin_file_info));
claimed_files[num_claimed_files - 1] = lto_file;
goto cleanup;
err:
- if (file->offset != 0)
- {
- int t = unlink (lto_file.name);
- assert (t == 0);
- }
free (lto_file.name);
cleanup:
debug = 1;
else if (strcmp (option, "-nop") == 0)
nop = 1;
- else if (!strncmp (option, "-resolution=", strlen("-resolution=")))
- {
- resolution_file = strdup (option + strlen("-resolution="));
- }
else if (!strncmp (option, "-pass-through=", strlen("-pass-through=")))
{
num_pass_through_items++;
- pass_through_items = realloc (pass_through_items,
- num_pass_through_items * sizeof (char *));
+ pass_through_items = xrealloc (pass_through_items,
+ num_pass_through_items * sizeof (char *));
pass_through_items[num_pass_through_items - 1] =
- strdup (option + strlen ("-pass-through="));
+ xstrdup (option + strlen ("-pass-through="));
}
else
{
int size;
+ char *opt = xstrdup (option);
lto_wrapper_num_args += 1;
size = lto_wrapper_num_args * sizeof (char *);
- lto_wrapper_argv = (char **) realloc (lto_wrapper_argv, size);
- lto_wrapper_argv[lto_wrapper_num_args - 1] = strdup(option);
+ lto_wrapper_argv = (char **) xrealloc (lto_wrapper_argv, size);
+ lto_wrapper_argv[lto_wrapper_num_args - 1] = opt;
+ if (strncmp (option, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
+ resolution_file = opt + sizeof ("-fresolution=") - 1;
}
}
{
struct ld_plugin_tv *p;
enum ld_plugin_status status;
- char *t;
unsigned version = elf_version (EV_CURRENT);
- assert (version != EV_NONE);
+ check (version != EV_NONE, LDPL_FATAL, "invalid ELF version");
p = tv;
while (p->tv_tag)
{
switch (p->tv_tag)
{
+ case LDPT_MESSAGE:
+ message = p->tv_u.tv_message;
+ break;
case LDPT_REGISTER_CLAIM_FILE_HOOK:
register_claim_file = p->tv_u.tv_register_claim_file;
break;
p++;
}
- assert (register_claim_file);
- assert (add_symbols);
+ check (register_claim_file, LDPL_FATAL, "register_claim_file not found");
+ check (add_symbols, LDPL_FATAL, "add_symbols not found");
status = register_claim_file (claim_file_handler);
- assert (status == LDPS_OK);
+ check (status == LDPS_OK, LDPL_FATAL,
+ "could not register the claim_file callback");
if (register_cleanup)
{
status = register_cleanup (cleanup_handler);
- assert (status == LDPS_OK);
+ check (status == LDPS_OK, LDPL_FATAL,
+ "could not register the cleanup callback");
}
if (register_all_symbols_read)
{
- assert (get_symbols);
+ check (get_symbols, LDPL_FATAL, "get_symbols not found");
status = register_all_symbols_read (all_symbols_read_handler);
- assert (status == LDPS_OK);
+ check (status == LDPS_OK, LDPL_FATAL,
+ "could not register the all_symbols_read callback");
}
- temp_obj_dir_name = strdup ("tmp_objectsXXXXXX");
- t = mkdtemp (temp_obj_dir_name);
- assert (t == temp_obj_dir_name);
return LDPS_OK;
}
OSDN Git Service
