X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=lto-plugin%2Flto-plugin.c;h=5ca4c9a27a31269df761b6cde3fdffd06adfc3a3;hp=d6b0a7727a464ffa02c5b55c0f266a6974d9b8af;hb=13ac7a0f8ccbc9b5c1edb8e23ff43d62b0ba0534;hpb=0793438f2e735b5e4fe2208e88dc541592e039d0 diff --git a/lto-plugin/lto-plugin.c b/lto-plugin/lto-plugin.c index d6b0a7727a4..5ca4c9a27a3 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 @@ -32,6 +32,12 @@ along with this program; see the file COPYING3. If not see -nop: Instead of running lto-wrapper, pass the original to the plugin. This only works if the input files are hybrid. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#if HAVE_STDINT_H +#include +#endif #include #include #include @@ -41,15 +47,36 @@ along with this program; see the file COPYING3. If not see #include #include #include +#ifdef HAVE_SYS_WAIT_H #include -#include +#endif +#ifndef WIFEXITED +#define WIFEXITED(S) (((S) & 0xff) == 0) +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(S) (((S) & 0xff00) >> 8) +#endif #include +#include +#include "../gcc/lto/common.h" +#include "simple-object.h" +#include "plugin-api.h" -/* The presence of gelf.h is checked by the toplevel configure script. */ -#include +/* Handle opening elf files on hosts, such as Windows, that may use + text file handling that will break binary access. */ +#ifndef O_BINARY +# define O_BINARY 0 +#endif -#include "plugin-api.h" -#include "../gcc/lto/common.h" +/* Segment name for LTO sections. This is only used for Mach-O. + FIXME: This needs to be kept in sync with darwin.c. */ + +#define LTO_SEGMENT_NAME "__GNU_LTO" + +/* LTO magic section name. */ + +#define LTO_SECTION_PREFIX ".gnu.lto_.symtab" +#define LTO_SECTION_PREFIX_LEN (sizeof (LTO_SECTION_PREFIX) - 1) /* 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 @@ -59,6 +86,7 @@ struct sym_aux { uint32_t slot; unsigned id; + unsigned next_conflict; }; struct plugin_symtab @@ -69,6 +97,15 @@ struct plugin_symtab unsigned id; }; +/* Encapsulates object file data during symbol scan. */ +struct plugin_objfile +{ + int found; + simple_object_read *objfile; + struct plugin_symtab *out; + const struct ld_plugin_input_file *file; +}; + /* All that we have to remember about a file. */ struct plugin_file_info @@ -76,18 +113,28 @@ struct plugin_file_info char *name; void *handle; struct plugin_symtab symtab; + struct plugin_symtab conflicts; }; +/* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from + stdio file streams, we do simple label translation here. */ + +enum symbol_style +{ + ss_none, /* No underscore prefix. */ + ss_win32, /* Underscore prefix any symbol not beginning with '@'. */ + ss_uscore, /* Underscore prefix all symbols. */ +}; 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; static ld_plugin_add_input_file add_input_file; static ld_plugin_add_input_library add_input_library; static ld_plugin_message message; +static ld_plugin_add_symbols add_symbols; static struct plugin_file_info *claimed_files = NULL; static unsigned int num_claimed_files = 0; @@ -101,12 +148,17 @@ static int lto_wrapper_num_args; static char **pass_through_items = NULL; static unsigned int num_pass_through_items; -static bool debug; -static bool nop; +static char debug; +static char nop; static char *resolution_file = NULL; +/* Set by default from configure.ac, but can be overridden at runtime + by using -plugin-opt=-sym-style={none,win32,underscore|uscore} + (in fact, only first letter of style arg is checked.) */ +static enum symbol_style sym_style = SYM_STYLE; + static void -check (bool gate, enum ld_plugin_level level, const char *text) +check_1 (int gate, enum ld_plugin_level level, const char *text) { if (gate) return; @@ -122,6 +174,11 @@ check (bool gate, enum ld_plugin_level level, const char *text) } } +/* This little wrapper allows check to be called with a non-integer + first argument, such as a pointer that must be non-NULL. We can't + use c99 bool type to coerce it into range, so we explicitly test. */ +#define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT)) + /* 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. */ @@ -148,7 +205,24 @@ parse_table_entry (char *p, struct ld_plugin_symbol *entry, LDPV_HIDDEN }; - entry->name = xstrdup (p); + switch (sym_style) + { + case ss_win32: + if (p[0] == '@') + { + /* cf. Duff's device. */ + case ss_none: + entry->name = xstrdup (p); + break; + } + /* FALL-THROUGH. */ + case ss_uscore: + entry->name = concat ("_", p, NULL); + break; + default: + check (0, LDPL_FATAL, "invalid symbol style requested"); + break; + } while (*p) p++; p++; @@ -183,19 +257,18 @@ parse_table_entry (char *p, struct ld_plugin_symbol *entry, entry->resolution = LDPR_UNKNOWN; + aux->next_conflict = -1; + return p; } -#define LTO_SECTION_PREFIX ".gnu.lto_.symtab" - -/* Translate the IL symbol table SYMTAB. Append the slots and symbols to 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) +translate (char *data, char *end, 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; @@ -219,39 +292,6 @@ translate (Elf_Data *symtab, struct plugin_symtab *out) 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 0; - 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 (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; - } - } - return found; -} - /* Free all memory that is no longer needed after writing the symbol resolution. */ @@ -303,6 +343,82 @@ free_2 (void) arguments_file_name = NULL; } +/* Dump SYMTAB to resolution file F. */ + +static void +dump_symtab (FILE *f, struct plugin_symtab *symtab) +{ + unsigned j; + + for (j = 0; j < symtab->nsyms; j++) + { + 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 @@ -322,18 +438,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; 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->aux[j].slot; - unsigned int resolution = syms[j].resolution; - fprintf (f, "%d %x %s %s\n", slot, symtab->aux[j].id, - lto_resolution_str[resolution], syms[j].name); + dump_symtab (f, &info->conflicts); + free_symtab (&info->conflicts); } } fclose (f); @@ -354,7 +469,10 @@ add_output_files (FILE *f) buf = s; cont: if (!fgets (buf, piece, f)) - break; + { + free (s); + break; + } len = strlen (s); if (s[len - 1] != '\n') { @@ -550,6 +668,164 @@ cleanup_handler (void) return LDPS_OK; } +#define SWAP(type, a, b) \ + do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0) + +/* Compare two hash table entries */ + +static int eq_sym (const void *a, const void *b) +{ + const struct ld_plugin_symbol *as = (const struct ld_plugin_symbol *)a; + const struct ld_plugin_symbol *bs = (const struct ld_plugin_symbol *)b; + + 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; + } +} + +/* 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). + + We have to keep that in the LTO symbol tables, but the dups confuse + gold and then finally gcc by supplying incorrect resolutions. + + Problem is that the main gold symbol table doesn't know about subids + and does not distingush the same symbols in different states. + + 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. + + Then when writing out the resolution file readd the dropped symbols. + + XXX how to handle common? */ + +static 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; + + 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; + } + + /* Remove previous duplicates in the main table */ + if (out < i) + { + t->syms[out] = *s; + t->aux[out] = *aux; + } + + /* Put original into the hash table */ + *slot = &t->syms[out]; + out++; + } + + assert (conflicts->nsyms <= outlen); + assert (conflicts->nsyms + out == t->nsyms); + + t->nsyms = out; + htab_delete (symtab); +} + +/* Process one section of an object file. */ + +static int +process_symtab (void *data, const char *name, off_t offset, off_t length) +{ + struct plugin_objfile *obj = (struct plugin_objfile *)data; + char *s; + char *secdata; + + if (strncmp (name, LTO_SECTION_PREFIX, LTO_SECTION_PREFIX_LEN) != 0) + return 1; + + s = strrchr (name, '.'); + if (s) + sscanf (s, ".%x", &obj->out->id); + secdata = xmalloc (length); + offset += obj->file->offset; + if (offset != lseek (obj->file->fd, offset, SEEK_SET) + || length != read (obj->file->fd, secdata, length)) + { + if (message) + message (LDPL_FATAL, "%s: corrupt object file", obj->file->name); + /* Force claim_file_handler to abandon this file. */ + obj->found = 0; + free (secdata); + return 0; + } + + translate (secdata, secdata + length, obj->out); + obj->found++; + free (secdata); + return 1; +} + /* Callback used by gold to check if the plugin will claim FILE. Writes the result in CLAIMED. */ @@ -557,49 +833,63 @@ static enum ld_plugin_status claim_file_handler (const struct ld_plugin_input_file *file, int *claimed) { enum ld_plugin_status status; - Elf *elf; + struct plugin_objfile obj; struct plugin_file_info lto_file; + int err; + const char *errmsg; memset (<o_file, 0, sizeof (struct plugin_file_info)); 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@0x%" PRIx64, file->name, - (int64_t) file->offset); + /* We pass the offset of the actual file, not the archive header. + Can't use PRIx64, because that's C99, so we have to print the + 64-bit hex int as two 32-bit ones. */ + int lo, hi; + lo = file->offset & 0xffffffff; + hi = ((int64_t)file->offset >> 32) & 0xffffffff; + int t = hi ? asprintf (&objname, "%s@0x%x%08x", file->name, lo, hi) + : asprintf (&objname, "%s@0x%x", file->name, lo); 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 = xstrdup (file->name); - elf = elf_begin (file->fd, ELF_C_READ, NULL); } lto_file.handle = file->handle; *claimed = 0; + obj.file = file; + obj.found = 0; + obj.out = <o_file.symtab; + errmsg = NULL; + obj.objfile = simple_object_start_read (file->fd, file->offset, LTO_SEGMENT_NAME, + &errmsg, &err); + /* No file, but also no error code means unrecognized format; just skip it. */ + if (!obj.objfile && !err) + goto err; + + if (obj.objfile) + errmsg = simple_object_find_sections (obj.objfile, process_symtab, &obj, &err); + + if (!obj.objfile || errmsg) + { + if (err && message) + message (LDPL_FATAL, "%s: %s: %s", file->name, errmsg, + xstrerror (err)); + else if (message) + message (LDPL_FATAL, "%s: %s", file->name, errmsg); + goto err; + } - if (!elf || !process_symtab (elf, <o_file.symtab)) + if (obj.found == 0) goto err; + if (obj.found > 1) + resolve_conflicts (<o_file.symtab, <o_file.conflicts); + status = add_symbols (file->handle, lto_file.symtab.nsyms, lto_file.symtab.syms); check (status == LDPS_OK, LDPL_FATAL, "could not add symbols"); @@ -617,8 +907,8 @@ claim_file_handler (const struct ld_plugin_input_file *file, int *claimed) free (lto_file.name); cleanup: - if (elf) - elf_end (elf); + if (obj.objfile) + simple_object_release_read (obj.objfile); return LDPS_OK; } @@ -640,6 +930,21 @@ process_option (const char *option) pass_through_items[num_pass_through_items - 1] = xstrdup (option + strlen ("-pass-through=")); } + else if (!strncmp (option, "-sym-style=", sizeof ("-sym-style=") - 1)) + { + switch (option[sizeof ("-sym-style=") - 1]) + { + case 'w': + sym_style = ss_win32; + break; + case 'u': + sym_style = ss_uscore; + break; + default: + sym_style = ss_none; + break; + } + } else { int size; @@ -661,9 +966,6 @@ 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"); - p = tv; while (p->tv_tag) {