X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=lto-plugin%2Flto-plugin.c;h=433f545391f2f0e7925813a1e807cdb0aca74a2c;hb=226448e15453076aaa0dbc76d9ebfb14a62b5bb1;hp=e8e88cbb3c75152f44c99f6c41547023292dd34e;hpb=5021761179f2c1d44bcea22d8cb7b6e71f83b855;p=pf3gnuchains%2Fgcc-fork.git diff --git a/lto-plugin/lto-plugin.c b/lto-plugin/lto-plugin.c index e8e88cbb3c7..433f545391f 100644 --- a/lto-plugin/lto-plugin.c +++ b/lto-plugin/lto-plugin.c @@ -1,5 +1,5 @@ -/* LTO plugin for gold. - Copyright (C) 2009 Free Software Foundation, Inc. +/* LTO plugin for gold and/or GNU ld. + Copyright (C) 2009, 2010 Free Software Foundation, Inc. Contributed by Rafael Avila de Espindola (espindola@google.com). This program is free software; you can redistribute it and/or modify @@ -44,37 +44,14 @@ along with this program; see the file COPYING3. If not see #include #include #include - -/* The presence of gelf.h is checked by the toplevel configure script. */ -#include - -#include "plugin-api.h" +#include #include "../gcc/lto/common.h" -/* The part of the symbol table the plugin has to keep track of. Note that we - must keep SYMS until all_symbols_read is called to give the linker time to - copy the symbol information. */ - -struct plugin_symtab -{ - int nsyms; - uint32_t *slots; - struct ld_plugin_symbol *syms; -}; - -/* All that we have to remember about a file. */ - -struct plugin_file_info -{ - char *name; - void *handle; - struct plugin_symtab symtab; -}; - +/* Common definitions for/from the object format dependent code. */ +#include "lto-plugin.h" 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_get_symbols get_symbols; static ld_plugin_register_cleanup register_cleanup; @@ -82,8 +59,12 @@ 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; +/* These are not static because the object format dependent + claim_file hooks in lto-plugin-{coff,elf}.c need them. */ +ld_plugin_add_symbols add_symbols; + +struct plugin_file_info *claimed_files = NULL; +unsigned int num_claimed_files = 0; static char **output_files = NULL; static unsigned int num_output_files = 0; @@ -98,7 +79,7 @@ static bool debug; static bool nop; static char *resolution_file = NULL; -static void +void check (bool gate, enum ld_plugin_level level, const char *text) { if (gate) @@ -119,8 +100,9 @@ check (bool gate, enum ld_plugin_level level, const char *text) by P and the result is written in ENTRY. The slot number is stored in SLOT. Returns the address of the next entry. */ -static char * -parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot) +char * +parse_table_entry (char *p, struct ld_plugin_symbol *entry, + struct sym_aux *aux) { unsigned char t; enum ld_plugin_symbol_kind translate_kind[] = @@ -140,7 +122,7 @@ parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot) LDPV_HIDDEN }; - entry->name = strdup (p); + entry->name = xstrdup (p); while (*p) p++; p++; @@ -155,7 +137,7 @@ parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot) 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"); @@ -170,79 +152,44 @@ parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot) 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. */ + aux->next_conflict = -1; -static Elf_Scn * -get_section (Elf *elf, const char *name) -{ - Elf_Scn *section = 0; - GElf_Ehdr header; - GElf_Ehdr *t = gelf_getehdr (elf, &header); - if (t == NULL) - return NULL; - assert (t == &header); - - while ((section = elf_nextscn(elf, section)) != 0) - { - GElf_Shdr shdr; - GElf_Shdr *tshdr = gelf_getshdr (section, &shdr); - const char *t; - 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; + return p; } -/* Translate the IL symbol table SYMTAB. Write the slots and symbols in OUT. */ +/* Translate the IL symbol table located between DATA and END. Append the + slots and symbols to OUT. */ -static void -translate (Elf_Data *symtab, struct plugin_symtab *out) +void +translate (char *data, char *end, struct plugin_symtab *out) { - uint32_t *slots = NULL; - char *data = symtab->d_buf; - char *end = data + symtab->d_size; + struct sym_aux *aux; 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]); + 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]); } + assert(n < len); + out->nsyms = n; out->syms = syms; - out->slots = slots; + out->aux = aux; } /* Free all memory that is no longer needed after writing the symbol @@ -279,7 +226,7 @@ free_2 (void) { struct plugin_file_info *info = &claimed_files[i]; struct plugin_symtab *symtab = &info->symtab; - free (symtab->slots); + free (symtab->aux); free (info->name); } @@ -294,14 +241,84 @@ free_2 (void) if (arguments_file_name) free (arguments_file_name); arguments_file_name = NULL; +} + +/* Dump SYMTAB to resolution file F. */ - if (resolution_file) +static void +dump_symtab (FILE *f, struct plugin_symtab *symtab) +{ + unsigned j; + + for (j = 0; j < symtab->nsyms; j++) { - free (resolution_file); - resolution_file = NULL; + uint32_t slot = symtab->aux[j].slot; + unsigned int resolution = symtab->syms[j].resolution; + + assert (resolution != LDPR_UNKNOWN); + + fprintf (f, "%u %x %s %s\n", (unsigned int) slot, symtab->aux[j].id, + lto_resolution_str[resolution], + symtab->syms[j].name); } } +/* Finish the conflicts' resolution information after the linker resolved + the original symbols */ + +static void +finish_conflict_resolution (struct plugin_symtab *symtab, + struct plugin_symtab *conflicts) +{ + int i, j; + + if (conflicts->nsyms == 0) + return; + + for (i = 0; i < symtab->nsyms; i++) + { + int resolution = LDPR_UNKNOWN; + + if (symtab->aux[i].next_conflict == -1) + continue; + + switch (symtab->syms[i].def) + { + case LDPK_DEF: + case LDPK_COMMON: /* ??? */ + resolution = LDPR_RESOLVED_IR; + break; + case LDPK_WEAKDEF: + resolution = LDPR_PREEMPTED_IR; + break; + case LDPK_UNDEF: + case LDPK_WEAKUNDEF: + resolution = symtab->syms[i].resolution; + break; + default: + assert (0); + } + + assert (resolution != LDPR_UNKNOWN); + + for (j = symtab->aux[i].next_conflict; + j != -1; + j = conflicts->aux[j].next_conflict) + conflicts->syms[j].resolution = resolution; + } +} + +/* Free symbol table SYMTAB. */ + +static void +free_symtab (struct plugin_symtab *symtab) +{ + free (symtab->syms); + symtab->syms = NULL; + free (symtab->aux); + symtab->aux = NULL; +} + /* Writes the relocations to disk. */ static void @@ -310,9 +327,7 @@ write_resolution (void) 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"); @@ -323,18 +338,17 @@ write_resolution (void) struct plugin_file_info *info = &claimed_files[i]; struct plugin_symtab *symtab = &info->symtab; 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); + finish_conflict_resolution (symtab, &info->conflicts); - for (j = 0; j < info->symtab.nsyms; j++) + fprintf (f, "%s %d\n", info->name, symtab->nsyms + info->conflicts.nsyms); + dump_symtab (f, symtab); + if (info->conflicts.nsyms) { - uint32_t slot = symtab->slots[j]; - unsigned int resolution = syms[j].resolution; - fprintf (f, "%d %s\n", slot, lto_resolution_str[resolution]); + dump_symtab (f, &info->conflicts); + free_symtab (&info->conflicts); } } fclose (f); @@ -346,22 +360,29 @@ write_resolution (void) 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]); } } @@ -372,7 +393,7 @@ add_output_files (FILE *f) static void exec_lto_wrapper (char *argv[]) { - int t; + int t, i; int status; char *at_args; FILE *args; @@ -397,13 +418,24 @@ exec_lto_wrapper (char *argv[]) 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"); @@ -464,7 +496,7 @@ all_symbols_read_handler (void) 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); @@ -511,6 +543,7 @@ all_symbols_read_handler (void) static enum ld_plugin_status cleanup_handler (void) { + unsigned int i; int t; if (debug) @@ -522,86 +555,138 @@ cleanup_handler (void) 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"); + } + free_2 (); return LDPS_OK; } -/* Callback used by gold to check if the plugin will claim FILE. Writes - the result in CLAIMED. */ +#define SWAP(type, a, b) \ + do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0) -static enum ld_plugin_status -claim_file_handler (const struct ld_plugin_input_file *file, int *claimed) +/* Compare two hash table entries */ + +static int eq_sym (const void *a, const void *b) { - enum ld_plugin_status status; - Elf *elf; - struct plugin_file_info lto_file; - Elf_Data *symtab; + const struct ld_plugin_symbol *as = (const struct ld_plugin_symbol *)a; + const struct ld_plugin_symbol *bs = (const struct ld_plugin_symbol *)b; - if (file->offset != 0) - { - char *objname; - Elf *archive; - off_t offset; - /* We pass the offset of the actual file, not the archive header. */ - int t = asprintf (&objname, "%s@%" PRId64, file->name, - (int64_t) file->offset); - check (t >= 0, LDPL_FATAL, "asprintf failed"); - lto_file.name = objname; - - 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); - elf = elf_begin (file->fd, ELF_C_READ, NULL); + return !strcmp (as->name, bs->name); +} + +/* Hash a symbol */ + +static hashval_t hash_sym (const void *a) +{ + const struct ld_plugin_symbol *as = (const struct ld_plugin_symbol *)a; + + return htab_hash_string (as->name); +} + +/* Determine how strong a symbol is */ + +static int symbol_strength (struct ld_plugin_symbol *s) +{ + switch (s->def) + { + case LDPK_UNDEF: + case LDPK_WEAKUNDEF: + return 0; + case LDPK_WEAKDEF: + return 1; + default: + return 2; } - lto_file.handle = file->handle; +} - *claimed = 0; +/* In the ld -r case we can get dups in the LTO symbol tables, where + the same symbol can have different resolutions (e.g. undefined and defined). - if (!elf) - goto err; + We have to keep that in the LTO symbol tables, but the dups confuse + gold and then finally gcc by supplying incorrect resolutions. - symtab = get_symtab (elf); - if (!symtab) - goto err; + Problem is that the main gold symbol table doesn't know about subids + and does not distingush the same symbols in different states. - translate (symtab, <o_file.symtab); + So we drop duplicates from the linker visible symbol table + and keep them in a private table. Then later do own symbol + resolution for the duplicated based on the results for the + originals. - status = add_symbols (file->handle, lto_file.symtab.nsyms, - lto_file.symtab.syms); - check (status == LDPS_OK, LDPL_FATAL, "could not add symbols"); + Then when writing out the resolution file readd the dropped symbols. + + XXX how to handle common? */ - *claimed = 1; - num_claimed_files++; - claimed_files = - realloc (claimed_files, - num_claimed_files * sizeof (struct plugin_file_info)); - claimed_files[num_claimed_files - 1] = lto_file; +void +resolve_conflicts (struct plugin_symtab *t, struct plugin_symtab *conflicts) +{ + htab_t symtab = htab_create (t->nsyms, hash_sym, eq_sym, NULL); + int i; + int out; + int outlen; + + outlen = t->nsyms; + conflicts->syms = xmalloc (sizeof (struct ld_plugin_symbol) * outlen); + conflicts->aux = xmalloc (sizeof (struct sym_aux) * outlen); + + /* Move all duplicate symbols into the auxillary conflicts table. */ + out = 0; + for (i = 0; i < t->nsyms; i++) + { + struct ld_plugin_symbol *s = &t->syms[i]; + struct sym_aux *aux = &t->aux[i]; + void **slot; - goto cleanup; + slot = htab_find_slot (symtab, s, INSERT); + if (*slot != NULL) + { + int cnf; + struct ld_plugin_symbol *orig = (struct ld_plugin_symbol *)*slot; + struct sym_aux *orig_aux = &t->aux[orig - t->syms]; + + /* Always let the linker resolve the strongest symbol */ + if (symbol_strength (orig) < symbol_strength (s)) + { + SWAP (struct ld_plugin_symbol, *orig, *s); + SWAP (uint32_t, orig_aux->slot, aux->slot); + SWAP (unsigned, orig_aux->id, aux->id); + /* Don't swap conflict chain pointer */ + } + + /* Move current symbol into the conflicts table */ + cnf = conflicts->nsyms++; + conflicts->syms[cnf] = *s; + conflicts->aux[cnf] = *aux; + aux = &conflicts->aux[cnf]; + + /* Update conflicts chain of the original symbol */ + aux->next_conflict = orig_aux->next_conflict; + orig_aux->next_conflict = cnf; + + continue; + } - err: - free (lto_file.name); + /* Remove previous duplicates in the main table */ + if (out < i) + { + t->syms[out] = *s; + t->aux[out] = *aux; + } - cleanup: - if (elf) - elf_end (elf); + /* Put original into the hash table */ + *slot = &t->syms[out]; + out++; + } - return LDPS_OK; + assert (conflicts->nsyms <= outlen); + assert (conflicts->nsyms + out == t->nsyms); + + t->nsyms = out; + htab_delete (symtab); } /* Parse the plugin options. */ @@ -613,25 +698,24 @@ process_option (const char *option) 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; } } @@ -643,8 +727,9 @@ onload (struct ld_plugin_tv *tv) struct ld_plugin_tv *p; enum ld_plugin_status status; - unsigned version = elf_version (EV_CURRENT); - check (version != EV_NONE, LDPL_FATAL, "invalid ELF version"); + status = onload_format_checks (tv); + if (status != LDPS_OK) + return status; p = tv; while (p->tv_tag)