mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-24 11:29:10 +00:00
360 lines
9.1 KiB
C
360 lines
9.1 KiB
C
/* Code to maintain a C++ template repository.
|
|
Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005
|
|
Free Software Foundation, Inc.
|
|
Contributed by Jason Merrill (jason@cygnus.com)
|
|
|
|
This file is part of GCC.
|
|
|
|
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)
|
|
any later version.
|
|
|
|
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 GCC; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA. */
|
|
|
|
/* My strategy here is as follows:
|
|
|
|
Everything should be emitted in a translation unit where it is used.
|
|
The results of the automatic process should be easily reproducible with
|
|
explicit code. */
|
|
|
|
#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.h"
|
|
#include "flags.h"
|
|
|
|
static char *extract_string (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 GTY(()) tree pending_repo;
|
|
static char *repo_name;
|
|
|
|
static const char *old_args, *old_dir, *old_main;
|
|
|
|
static struct obstack temporary_obstack;
|
|
static bool temporary_obstack_initialized_p;
|
|
|
|
/* Parse a reasonable subset of shell quoting syntax. */
|
|
|
|
static char *
|
|
extract_string (char **pp)
|
|
{
|
|
char *p = *pp;
|
|
int backquote = 0;
|
|
int inside = 0;
|
|
|
|
for (;;)
|
|
{
|
|
char c = *p;
|
|
if (c == '\0')
|
|
break;
|
|
++p;
|
|
if (backquote)
|
|
{
|
|
obstack_1grow (&temporary_obstack, c);
|
|
backquote = 0;
|
|
}
|
|
else if (! inside && c == ' ')
|
|
break;
|
|
else if (! inside && c == '\\')
|
|
backquote = 1;
|
|
else if (c == '\'')
|
|
inside = !inside;
|
|
else
|
|
obstack_1grow (&temporary_obstack, c);
|
|
}
|
|
|
|
obstack_1grow (&temporary_obstack, '\0');
|
|
*pp = p;
|
|
return (char *) obstack_finish (&temporary_obstack);
|
|
}
|
|
|
|
static const char *
|
|
get_base_filename (const char *filename)
|
|
{
|
|
char *p = getenv ("COLLECT_GCC_OPTIONS");
|
|
char *output = NULL;
|
|
int compiling = 0;
|
|
|
|
while (p && *p)
|
|
{
|
|
char *q = extract_string (&p);
|
|
|
|
if (strcmp (q, "-o") == 0)
|
|
output = extract_string (&p);
|
|
else if (strcmp (q, "-c") == 0)
|
|
compiling = 1;
|
|
}
|
|
|
|
if (compiling && output)
|
|
return output;
|
|
|
|
if (p && ! compiling)
|
|
{
|
|
warning (0, "-frepo must be used with -c");
|
|
flag_use_repository = 0;
|
|
return NULL;
|
|
}
|
|
|
|
return lbasename (filename);
|
|
}
|
|
|
|
static FILE *
|
|
open_repo_file (const char *filename)
|
|
{
|
|
const char *p;
|
|
const char *s = get_base_filename (filename);
|
|
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
p = lbasename (s);
|
|
p = strrchr (p, '.');
|
|
if (! p)
|
|
p = s + strlen (s);
|
|
|
|
repo_name = XNEWVEC (char, p - s + 5);
|
|
memcpy (repo_name, s, p - s);
|
|
memcpy (repo_name + (p - s), ".rpo", 5);
|
|
|
|
return fopen (repo_name, "r");
|
|
}
|
|
|
|
static char *
|
|
afgets (FILE *stream)
|
|
{
|
|
int c;
|
|
while ((c = getc (stream)) != EOF && c != '\n')
|
|
obstack_1grow (&temporary_obstack, c);
|
|
if (obstack_object_size (&temporary_obstack) == 0)
|
|
return NULL;
|
|
obstack_1grow (&temporary_obstack, '\0');
|
|
return (char *) obstack_finish (&temporary_obstack);
|
|
}
|
|
|
|
void
|
|
init_repo (void)
|
|
{
|
|
char *buf;
|
|
FILE *repo_file;
|
|
|
|
if (! flag_use_repository)
|
|
return;
|
|
|
|
/* 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;
|
|
|
|
while ((buf = afgets (repo_file)))
|
|
{
|
|
switch (buf[0])
|
|
{
|
|
case 'A':
|
|
old_args = ggc_strdup (buf + 2);
|
|
break;
|
|
case 'D':
|
|
old_dir = ggc_strdup (buf + 2);
|
|
break;
|
|
case 'M':
|
|
old_main = ggc_strdup (buf + 2);
|
|
break;
|
|
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);
|
|
IDENTIFIER_REPO_CHOSEN (id) = 1;
|
|
}
|
|
break;
|
|
default:
|
|
error ("mysterious repository information in %s", repo_name);
|
|
}
|
|
obstack_free (&temporary_obstack, buf);
|
|
}
|
|
fclose (repo_file);
|
|
}
|
|
|
|
static FILE *
|
|
reopen_repo_file_for_write (void)
|
|
{
|
|
FILE *repo_file = fopen (repo_name, "w");
|
|
|
|
if (repo_file == 0)
|
|
{
|
|
error ("can't create repository information file %qs", repo_name);
|
|
flag_use_repository = 0;
|
|
}
|
|
|
|
return repo_file;
|
|
}
|
|
|
|
/* Emit any pending repos. */
|
|
|
|
void
|
|
finish_repo (void)
|
|
{
|
|
tree t;
|
|
char *dir, *args;
|
|
FILE *repo_file;
|
|
|
|
if (!flag_use_repository)
|
|
return;
|
|
|
|
if (errorcount || sorrycount)
|
|
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", 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'", flag_random_seed);
|
|
fprintf (repo_file, "\n");
|
|
}
|
|
|
|
for (t = pending_repo; t; t = TREE_CHAIN (t))
|
|
{
|
|
tree val = TREE_VALUE (t);
|
|
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)
|
|
{
|
|
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;
|
|
/* Static data members initialized by constant expressions must
|
|
be processed where needed so that their definitions are
|
|
available. */
|
|
if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
|
|
&& DECL_CLASS_SCOPE_P (decl))
|
|
return 2;
|
|
}
|
|
else if (!DECL_TEMPLATE_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;
|
|
pending_repo = tree_cons (NULL_TREE, decl, pending_repo);
|
|
}
|
|
|
|
return IDENTIFIER_REPO_CHOSEN (DECL_ASSEMBLER_NAME (decl));
|
|
}
|
|
|
|
/* Returns true iff the prelinker has explicitly marked CLASS_TYPE for
|
|
export from this translation unit. */
|
|
|
|
bool
|
|
repo_export_class_p (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"
|