#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
-#include <ar.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
must keep SYMS until all_symbols_read is called to give the linker time to
copy the symbol information. */
+struct sym_aux
+{
+ uint32_t slot;
+ unsigned id;
+};
+
struct plugin_symtab
{
int nsyms;
- uint32_t *slots;
+ struct sym_aux *aux;
struct ld_plugin_symbol *syms;
+ unsigned id;
};
/* All that we have to remember about a file. */
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;
Returns the address of the next entry. */
static char *
-parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot)
+parse_table_entry (char *p, struct ld_plugin_symbol *entry,
+ struct sym_aux *aux)
{
unsigned char t;
enum ld_plugin_symbol_kind translate_kind[] =
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;
check (t <= 4, LDPL_FATAL, "invalid symbol kind found");
entry->size = *(uint64_t *) p;
p += 8;
- *slot = *(uint32_t *) p;
+ aux->slot = *(uint32_t *) p;
p += 4;
entry->resolution = LDPR_UNKNOWN;
return p;
}
-/* Return the section in ELF that is named NAME. */
+#define LTO_SECTION_PREFIX ".gnu.lto_.symtab"
-static Elf_Scn *
-get_section (Elf *elf, const char *name)
+/* Translate the IL symbol table SYMTAB. Append the slots and symbols to OUT. */
+
+static void
+translate (Elf_Data *symtab, struct plugin_symtab *out)
{
+ struct sym_aux *aux;
+ char *data = symtab->d_buf;
+ char *end = data + symtab->d_size;
+ struct ld_plugin_symbol *syms = NULL;
+ int n, len;
+
+ /* This overestimates the output buffer sizes, but at least
+ the algorithm is O(1) now. */
+
+ len = (end - data)/8 + out->nsyms + 1;
+ syms = xrealloc (out->syms, len * sizeof (struct ld_plugin_symbol));
+ aux = xrealloc (out->aux, len * sizeof (struct sym_aux));
+
+ for (n = out->nsyms; data < end; n++)
+ {
+ aux[n].id = out->id;
+ data = parse_table_entry (data, &syms[n], &aux[n]);
+ }
+
+ fprintf (stderr, "n = %d len = %d end-data=%lu\n", n, len, end-data);
+ assert(n < len);
+
+ out->nsyms = n;
+ out->syms = syms;
+ out->aux = aux;
+}
+
+/* Process all lto symtabs of file ELF. */
+
+static int
+process_symtab (Elf *elf, struct plugin_symtab *out)
+{
+ int found = 0;
Elf_Scn *section = 0;
GElf_Ehdr header;
GElf_Ehdr *t = gelf_getehdr (elf, &header);
if (t == NULL)
- return NULL;
+ return 0;
assert (t == &header);
while ((section = elf_nextscn(elf, section)) != 0)
assert (tshdr == &shdr);
t = elf_strptr (elf, header.e_shstrndx, shdr.sh_name);
assert (t != NULL);
- if (strcmp (t, name) == 0)
- return section;
- }
- return NULL;
-}
-
-/* Returns the IL symbol table of file ELF. */
-
-static Elf_Data *
-get_symtab (Elf *elf)
-{
- Elf_Data *data = 0;
- Elf_Scn *section = get_section (elf, ".gnu.lto_.symtab");
- if (!section)
- return NULL;
-
- data = elf_getdata (section, data);
- assert (data);
- return data;
-}
-
-/* Translate the IL symbol table SYMTAB. Write the slots and symbols in OUT. */
-
-static void
-translate (Elf_Data *symtab, struct plugin_symtab *out)
-{
- uint32_t *slots = NULL;
- char *data = symtab->d_buf;
- char *end = data + symtab->d_size;
- struct ld_plugin_symbol *syms = NULL;
- int n = 0;
-
- while (data < end)
- {
- n++;
- syms = realloc (syms, n * sizeof (struct ld_plugin_symbol));
- check (syms, LDPL_FATAL, "could not allocate memory");
- slots = realloc (slots, n * sizeof (uint32_t));
- check (slots, LDPL_FATAL, "could not allocate memory");
- data = parse_table_entry (data, &syms[n - 1], &slots[n - 1]);
+ if (strncmp (t, LTO_SECTION_PREFIX, strlen (LTO_SECTION_PREFIX)) == 0)
+ {
+ char *s = strrchr (t, '.');
+ if (s)
+ sscanf (s, ".%x", &out->id);
+ translate (elf_getdata (section, NULL), out);
+ found = 1;
+ }
}
-
- out->nsyms = n;
- out->syms = syms;
- out->slots = slots;
+ return found;
}
/* Free all memory that is no longer needed after writing the symbol
{
struct plugin_file_info *info = &claimed_files[i];
struct plugin_symtab *symtab = &info->symtab;
- free (symtab->slots);
+ free (symtab->aux);
free (info->name);
}
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");
check (f, LDPL_FATAL, "could not open file");
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);
for (j = 0; j < info->symtab.nsyms; j++)
{
- uint32_t slot = symtab->slots[j];
+ uint32_t slot = symtab->aux[j].slot;
unsigned int resolution = syms[j].resolution;
- fprintf (f, "%d %s\n", slot, lto_resolution_str[resolution]);
+ fprintf (f, "%d %x %s %s\n", slot, symtab->aux[j].id,
+ lto_resolution_str[resolution], syms[j].name);
}
}
fclose (f);
static void
add_output_files (FILE *f)
{
- char fname[1000]; /* FIXME: Remove this restriction. */
-
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);
- check (s[len - 1] == '\n', LDPL_FATAL, "file name too long");
+ 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);
- check (t >= 0, LDPL_FATAL, "asprintf failed");
+ 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");
+ args = fopen (arguments_file_name, "w");
check (args, LDPL_FATAL, "could not open arguments file");
t = writeargv (&argv[1], args);
t = fclose (args);
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;
new_argv[2] = NULL;
if (debug)
{
- int i;
for (i = 0; new_argv[i]; i++)
fprintf (stderr, "%s ", new_argv[i]);
fprintf (stderr, "\n");
pex_free (pex);
- t = unlink (args_name);
- check (t == 0, LDPL_FATAL, "could not unlink arguments file");
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;
- char *arguments;
- struct stat buf;
-
- for (i = 0; i < num_claimed_files; i++)
- {
- struct plugin_file_info *info = &claimed_files[i];
- if (info->temp)
- {
- t = unlink (info->name);
- check (t == 0, LDPL_FATAL, "could not unlink temporary file");
- }
- }
if (debug)
return LDPS_OK;
- /* If we are being called from an error handler, it is possible
- that the arguments file is still exists. */
- t = asprintf (&arguments, "%s/arguments", temp_obj_dir_name);
- check (t >= 0, LDPL_FATAL, "asprintf failed");
- if (stat(arguments, &buf) == 0)
+ if (arguments_file_name)
{
- t = unlink (arguments);
+ t = unlink (arguments_file_name);
check (t == 0, LDPL_FATAL, "could not unlink arguments file");
}
- free (arguments);
- t = rmdir (temp_obj_dir_name);
- check (t == 0, LDPL_FATAL, "could not remove temporary directory");
+ for (i = 0; i < num_output_files; i++)
+ {
+ t = unlink (output_files[i]);
+ check (t == 0, LDPL_FATAL, "could not unlink output file");
+ }
free_2 ();
return LDPS_OK;
enum ld_plugin_status status;
Elf *elf;
struct plugin_file_info lto_file;
- Elf_Data *symtab;
- int lto_file_fd;
+
+ memset (<o_file, 0, sizeof (struct plugin_file_info));
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);
+ 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");
- objnum++;
-
- fd = open (objname, O_RDWR | O_CREAT, 0666);
- check (fd > 0, LDPL_FATAL, "could not open/create temporary file");
- offset = lseek (file->fd, file->offset, SEEK_SET);
- check (offset == file->offset, LDPL_FATAL, "could not seek");
- 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);
- check (written == r, LDPL_FATAL, "could not write to temporary file");
- size -= r;
- }
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;
- if (!elf)
- goto err;
-
- symtab = get_symtab (elf);
- if (!symtab)
+ if (!elf || !process_symtab (elf, <o_file.symtab))
goto err;
- translate (symtab, <o_file.symtab);
-
status = add_symbols (file->handle, lto_file.symtab.nsyms,
lto_file.symtab.syms);
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);
- check (t == 0, LDPL_FATAL, "could not unlink file");
- }
free (lto_file.name);
cleanup:
if (elf)
elf_end (elf);
- if (file->offset != 0)
- close (lto_file_fd);
-
return LDPS_OK;
}
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);
check (version != EV_NONE, LDPL_FATAL, "invalid ELF version");
"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;
}