X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcp%2Frepo.c;h=16a192e4de966639cb1d6f60b832b9d39cc405a5;hb=1e944a0b51698cfea09da04479be167faec7885e;hp=90ce84551d078a309e27abab3583db43fa1f8e42;hpb=ab42e0f98714a22e80ede85bbf5081e678468d7d;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/cp/repo.c b/gcc/cp/repo.c index 90ce84551d0..16a192e4de9 100644 --- a/gcc/cp/repo.c +++ b/gcc/cp/repo.c @@ -1,23 +1,23 @@ /* Code to maintain a C++ template repository. - Copyright (C) 1995, 96-97, 1998 Free Software Foundation, Inc. + Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Jason Merrill (jason@cygnus.com) -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify +GCC 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 2, or (at your option) +the Free Software Foundation; either version 3, or (at your option) any later version. -GNU CC is distributed in the hope that it will be useful, +GCC 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 GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ /* My strategy here is as follows: @@ -27,190 +27,36 @@ Boston, MA 02111-1307, USA. */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "tree.h" #include "cp-tree.h" #include "input.h" #include "obstack.h" #include "toplev.h" +#include "diagnostic-core.h" +#include "flags.h" -extern char *getpwd PROTO((void)); +static const char *extract_string (const char **); +static const char *get_base_filename (const char *); +static FILE *open_repo_file (const char *); +static char *afgets (FILE *); +static FILE *reopen_repo_file_for_write (void); -static tree repo_get_id PROTO((tree)); -static char *extract_string PROTO((char **)); -static char *get_base_filename PROTO((char *)); -static void open_repo_file PROTO((char *)); -static char *afgets PROTO((FILE *)); -static void reopen_repo_file_for_write PROTO((void)); - -static tree pending_repo; -static tree original_repo; +static GTY(()) VEC(tree,gc) *pending_repo; static char *repo_name; -static FILE *repo_file; - -static char *old_args, *old_dir, *old_main; - -extern int flag_use_repository; -extern int errorcount, sorrycount; -extern struct obstack temporary_obstack; -extern struct obstack permanent_obstack; - -#define IDENTIFIER_REPO_USED(NODE) (TREE_LANG_FLAG_3 (NODE)) -#define IDENTIFIER_REPO_CHOSEN(NODE) (TREE_LANG_FLAG_4 (NODE)) - -#if 0 -/* Record the flags used to compile this translation unit. */ - -void -repo_compile_flags (argc, argv) - int argc; - char **argv; -{ -} -/* If this template has not been seen before, add a note to the repository - saying where the declaration was. This may be used to find the - definition at link time. */ +static const char *old_args, *old_dir, *old_main; -void -repo_template_declared (t) - tree t; -{} - -/* Note where the definition of a template lives so that instantiations can - be generated later. */ - -void -repo_template_defined (t) - tree t; -{} - -/* Note where the definition of a class lives to that template - instantiations can use it. */ - -void -repo_class_defined (t) - tree t; -{} -#endif - -static tree -repo_get_id (t) - tree t; -{ - if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') - { - /* If we're not done setting up the class, we may not have set up - the vtable, so going ahead would give the wrong answer. - See g++.pt/instantiate4.C. */ - if (TYPE_SIZE (t) == NULL_TREE || TYPE_BEING_DEFINED (t)) - my_friendly_abort (981113); - - t = TYPE_BINFO_VTABLE (t); - if (t == NULL_TREE) - return t; - } - return DECL_ASSEMBLER_NAME (t); -} - -/* Note that a template has been used. If we can see the definition, offer - to emit it. */ - -void -repo_template_used (t) - tree t; -{ - tree id; - - if (! flag_use_repository) - return; - - id = repo_get_id (t); - if (id == NULL_TREE) - return; - - if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') - { - if (IDENTIFIER_REPO_CHOSEN (id)) - mark_class_instantiated (t, 0); - } - else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd') - { - if (IDENTIFIER_REPO_CHOSEN (id)) - mark_decl_instantiated (t, 0); - } - else - my_friendly_abort (1); - - if (! IDENTIFIER_REPO_USED (id)) - { - IDENTIFIER_REPO_USED (id) = 1; - pending_repo = perm_tree_cons (NULL_TREE, id, pending_repo); - } -} - -#if 0 -/* Note that the vtable for a class has been used, and offer to emit it. */ - -static void -repo_vtable_used (t) - tree t; -{ - if (! flag_use_repository) - return; - - pending_repo = perm_tree_cons (NULL_TREE, t, pending_repo); -} - -/* Note that an inline with external linkage has been used, and offer to - emit it. */ - -void -repo_inline_used (fn) - tree fn; -{ - if (! flag_use_repository) - return; - - /* Member functions of polymorphic classes go with their vtables. */ - if (DECL_FUNCTION_MEMBER_P (fn) && TYPE_VIRTUAL_P (DECL_CLASS_CONTEXT (fn))) - { - repo_vtable_used (DECL_CLASS_CONTEXT (fn)); - return; - } - - pending_repo = perm_tree_cons (NULL_TREE, fn, pending_repo); -} - -/* Note that a particular typeinfo node has been used, and offer to - emit it. */ - -void -repo_tinfo_used (ti) - tree ti; -{ -} -#endif - -void -repo_template_instantiated (t, extern_p) - tree t; - int extern_p; -{ - if (! extern_p) - { - tree id = repo_get_id (t); - if (id) - IDENTIFIER_REPO_CHOSEN (id) = 1; - } -} +static struct obstack temporary_obstack; +static bool temporary_obstack_initialized_p; /* Parse a reasonable subset of shell quoting syntax. */ -static char * -extract_string (pp) - char **pp; +static const char * +extract_string (const char **pp) { - char *p = *pp; + const char *p = *pp; int backquote = 0; int inside = 0; @@ -221,7 +67,10 @@ extract_string (pp) break; ++p; if (backquote) - obstack_1grow (&temporary_obstack, c); + { + obstack_1grow (&temporary_obstack, c); + backquote = 0; + } else if (! inside && c == ' ') break; else if (! inside && c == '\\') @@ -234,64 +83,70 @@ extract_string (pp) obstack_1grow (&temporary_obstack, '\0'); *pp = p; - return obstack_finish (&temporary_obstack); + return (char *) obstack_finish (&temporary_obstack); } -static char * -get_base_filename (filename) - char *filename; +static const char * +get_base_filename (const char *filename) { - char *p = getenv ("COLLECT_GCC_OPTIONS"); - char *output = NULL; + const char *p = getenv ("COLLECT_GCC_OPTIONS"); + const char *output = NULL; int compiling = 0; while (p && *p) { - char *q = extract_string (&p); + const char *q = extract_string (&p); if (strcmp (q, "-o") == 0) - output = extract_string (&p); + { + if (flag_compare_debug) + /* Just in case aux_base_name was based on a name with two + or more '.'s, add an arbitrary extension that will be + stripped by the caller. */ + output = concat (aux_base_name, ".o", NULL); + else + output = extract_string (&p); + } else if (strcmp (q, "-c") == 0) compiling = 1; - } + } if (compiling && output) return output; if (p && ! compiling) { - warning ("-frepo must be used with -c"); + warning (0, "-frepo must be used with -c"); flag_use_repository = 0; return NULL; } - return file_name_nondirectory (filename); -} + return lbasename (filename); +} -static void -open_repo_file (filename) - char *filename; +static FILE * +open_repo_file (const char *filename) { - register char *p; - char *s = get_base_filename (filename); + const char *p; + const char *s = get_base_filename (filename); if (s == NULL) - return; + return NULL; - p = file_name_nondirectory (s); - p = rindex (p, '.'); + p = lbasename (s); + p = strrchr (p, '.'); if (! p) p = s + strlen (s); - obstack_grow (&permanent_obstack, s, p - s); - repo_name = obstack_copy0 (&permanent_obstack, ".rpo", 4); + repo_name = XNEWVEC (char, p - s + 5); + memcpy (repo_name, s, p - s); + memcpy (repo_name + (p - s), ".rpo", 5); - repo_file = fopen (repo_name, "r"); + return fopen (repo_name, "r"); } static char * -afgets (stream) - FILE *stream; +afgets (FILE *stream) { int c; while ((c = getc (stream)) != EOF && c != '\n') @@ -299,19 +154,28 @@ afgets (stream) if (obstack_object_size (&temporary_obstack) == 0) return NULL; obstack_1grow (&temporary_obstack, '\0'); - return obstack_finish (&temporary_obstack); + return (char *) obstack_finish (&temporary_obstack); } void -init_repo (filename) - char *filename; +init_repo (void) { char *buf; + const char *p; + FILE *repo_file; if (! flag_use_repository) return; - open_repo_file (filename); + /* When a PCH file is loaded, the entire identifier table is + replaced, with the result that IDENTIFIER_REPO_CHOSEN is cleared. + So, we have to reread the repository file. */ + lang_post_pch_load = init_repo; + + if (!temporary_obstack_initialized_p) + gcc_obstack_init (&temporary_obstack); + + repo_file = open_repo_file (main_input_filename); if (repo_file == 0) return; @@ -321,32 +185,24 @@ init_repo (filename) switch (buf[0]) { case 'A': - old_args = obstack_copy0 (&permanent_obstack, buf + 2, - strlen (buf + 2)); + old_args = ggc_strdup (buf + 2); break; case 'D': - old_dir = obstack_copy0 (&permanent_obstack, buf + 2, - strlen (buf + 2)); + old_dir = ggc_strdup (buf + 2); break; case 'M': - old_main = obstack_copy0 (&permanent_obstack, buf + 2, - strlen (buf + 2)); + old_main = ggc_strdup (buf + 2); break; - case 'C': case 'O': + /* A symbol that we were able to define the last time this + file was compiled. */ + break; + case 'C': + /* A symbol that the prelinker has requested that we + define. */ { tree id = get_identifier (buf + 2); - tree orig; - - if (buf[0] == 'C') - { - IDENTIFIER_REPO_CHOSEN (id) = 1; - orig = integer_one_node; - } - else - orig = NULL_TREE; - - original_repo = perm_tree_cons (orig, id, original_repo); + IDENTIFIER_REPO_CHOSEN (id) = 1; } break; default: @@ -354,94 +210,168 @@ init_repo (filename) } obstack_free (&temporary_obstack, buf); } + fclose (repo_file); + + if (old_args && !get_random_seed (true) + && (p = strstr (old_args, "'-frandom-seed="))) + set_random_seed (extract_string (&p) + strlen ("-frandom-seed=")); } -static void -reopen_repo_file_for_write () +static FILE * +reopen_repo_file_for_write (void) { - if (repo_file) - fclose (repo_file); - repo_file = fopen (repo_name, "w"); + FILE *repo_file = fopen (repo_name, "w"); if (repo_file == 0) { - error ("can't create repository information file `%s'", repo_name); + error ("can%'t create repository information file %qs", repo_name); flag_use_repository = 0; } + + return repo_file; } /* Emit any pending repos. */ void -finish_repo () +finish_repo (void) { - tree t; - int repo_changed = 0; + tree val; char *dir, *args; + FILE *repo_file; + unsigned ix; - if (! flag_use_repository) + if (!flag_use_repository || flag_compare_debug) return; - /* Do we have to write out a new info file? */ - - /* Are there any old templates that aren't used any longer or that are - newly chosen? */ - - for (t = original_repo; t; t = TREE_CHAIN (t)) - { - if (! IDENTIFIER_REPO_USED (TREE_VALUE (t)) - || (! TREE_PURPOSE (t) && IDENTIFIER_REPO_CHOSEN (TREE_VALUE (t)))) - { - repo_changed = 1; - break; - } - IDENTIFIER_REPO_USED (TREE_VALUE (t)) = 0; - } - - /* Are there any templates that are newly used? */ - - if (! repo_changed) - for (t = pending_repo; t; t = TREE_CHAIN (t)) - { - if (IDENTIFIER_REPO_USED (TREE_VALUE (t))) - { - repo_changed = 1; - break; - } - } - - dir = getpwd (); - args = getenv ("COLLECT_GCC_OPTIONS"); - - if (! repo_changed && pending_repo) - if (strcmp (old_main, main_input_filename) != 0 - || strcmp (old_dir, dir) != 0 - || (args == NULL) != (old_args == NULL) - || (args && strcmp (old_args, args) != 0)) - repo_changed = 1; - - if (! repo_changed || errorcount || sorrycount) - goto out; - - reopen_repo_file_for_write (); + if (seen_error ()) + return; + repo_file = reopen_repo_file_for_write (); if (repo_file == 0) goto out; fprintf (repo_file, "M %s\n", main_input_filename); + dir = getpwd (); fprintf (repo_file, "D %s\n", dir); + args = getenv ("COLLECT_GCC_OPTIONS"); if (args) - fprintf (repo_file, "A %s\n", args); - - for (t = pending_repo; t; t = TREE_CHAIN (t)) { - tree val = TREE_VALUE (t); - char type = IDENTIFIER_REPO_CHOSEN (val) ? 'C' : 'O'; + fprintf (repo_file, "A %s", args); + /* If -frandom-seed is not among the ARGS, then add the value + that we chose. That will ensure that the names of types from + anonymous namespaces will get the same mangling when this + file is recompiled. */ + if (!strstr (args, "'-frandom-seed=")) + fprintf (repo_file, " '-frandom-seed=%s'", get_random_seed (false)); + fprintf (repo_file, "\n"); + } - fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (val)); + FOR_EACH_VEC_ELT_REVERSE (tree, pending_repo, ix, val) + { + tree name = DECL_ASSEMBLER_NAME (val); + char type = IDENTIFIER_REPO_CHOSEN (name) ? 'C' : 'O'; + fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (name)); } out: if (repo_file) fclose (repo_file); } + +/* DECL is a FUNCTION_DECL or VAR_DECL with vague linkage whose + definition is available in this translation unit. Returns 0 if + this definition should not be emitted in this translation unit + because it will be emitted elsewhere. Returns 1 if the repository + file indicates that that DECL should be emitted in this translation + unit, or 2 if the repository file is not in use. */ + +int +repo_emit_p (tree decl) +{ + int ret = 0; + gcc_assert (TREE_PUBLIC (decl)); + gcc_assert (TREE_CODE (decl) == FUNCTION_DECL + || TREE_CODE (decl) == VAR_DECL); + gcc_assert (!DECL_REALLY_EXTERN (decl)); + + /* When not using the repository, emit everything. */ + if (!flag_use_repository) + return 2; + + /* Only template instantiations are managed by the repository. This + is an artificial restriction; the code in the prelinker and here + will work fine if all entities with vague linkage are managed by + the repository. */ + if (TREE_CODE (decl) == VAR_DECL) + { + tree type = NULL_TREE; + if (DECL_VTABLE_OR_VTT_P (decl)) + type = DECL_CONTEXT (decl); + else if (DECL_TINFO_P (decl)) + type = TREE_TYPE (DECL_NAME (decl)); + if (!DECL_TEMPLATE_INSTANTIATION (decl) + && (!TYPE_LANG_SPECIFIC (type) + || !CLASSTYPE_TEMPLATE_INSTANTIATION (type))) + return 2; + /* Const static data members initialized by constant expressions must + be processed where needed so that their definitions are + available. Still record them into *.rpo files, so if they + weren't actually emitted and collect2 requests them, they can + be provided. */ + if (decl_maybe_constant_var_p (decl) + && DECL_CLASS_SCOPE_P (decl)) + ret = 2; + } + else if (!DECL_TEMPLATE_INSTANTIATION (decl)) + return 2; + + if (DECL_EXPLICIT_INSTANTIATION (decl)) + return 2; + + /* For constructors and destructors, the repository contains + information about the clones -- not the original function -- + because only the clones are emitted in the object file. */ + if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl) + || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)) + { + int emit_p = 0; + tree clone; + /* There is no early exit from this loop because we want to + ensure that all of the clones are marked as available in this + object file. */ + FOR_EACH_CLONE (clone, decl) + /* The only possible results from the recursive call to + repo_emit_p are 0 or 1. */ + if (repo_emit_p (clone)) + emit_p = 1; + return emit_p; + } + + /* Keep track of all available entities. */ + if (!DECL_REPO_AVAILABLE_P (decl)) + { + DECL_REPO_AVAILABLE_P (decl) = 1; + VEC_safe_push (tree, gc, pending_repo, decl); + } + + return IDENTIFIER_REPO_CHOSEN (DECL_ASSEMBLER_NAME (decl)) ? 1 : ret; +} + +/* Returns true iff the prelinker has explicitly marked CLASS_TYPE for + export from this translation unit. */ + +bool +repo_export_class_p (const_tree class_type) +{ + if (!flag_use_repository) + return false; + if (!CLASSTYPE_VTABLES (class_type)) + return false; + /* If the virtual table has been assigned to this translation unit, + export the class. */ + return (IDENTIFIER_REPO_CHOSEN + (DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (class_type)))); +} + +#include "gt-cp-repo.h"