repo.c   [plain text]

/* Code to maintain a C++ template repository.
   Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004
   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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, 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"

static char *extract_string (char **);
static const char *get_base_filename (const char *);
static void open_repo_file (const char *);
static char *afgets (FILE *);
static void reopen_repo_file_for_write (void);

static GTY(()) tree pending_repo;
static char *repo_name;
static FILE *repo_file;

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 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 ("-frepo must be used with -c");
      flag_use_repository = 0;
      return NULL;
    }

  return lbasename (filename);
}        

static void
open_repo_file (const char *filename)
{
  const char *p;
  const char *s = get_base_filename (filename);

  if (s == NULL)
    return;

  p = lbasename (s);
  p = strrchr (p, '.');
  if (! p)
    p = s + strlen (s);

  repo_name = xmalloc (p - s + 5);
  memcpy (repo_name, s, p - s);
  memcpy (repo_name + (p - s), ".rpo", 5);

  repo_file = 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 obstack_finish (&temporary_obstack);
}

void
init_repo (void)
{
  char *buf;

  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);

  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 void
reopen_repo_file_for_write (void)
{
  repo_file = fopen (repo_name, "w");

  if (repo_file == 0)
    {
      error ("can't create repository information file %qs", repo_name);
      flag_use_repository = 0;
    }
}

/* Emit any pending repos.  */

void
finish_repo (void)
{
  tree t;
  char *dir, *args;

  if (!flag_use_repository)
    return;

  if (errorcount || sorrycount)
    goto out;

  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);
      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)
	  && !CLASSTYPE_TEMPLATE_INSTANTIATION (type))
	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"