gcc/cp/repo.c

   1 /* Code to maintain a C++ template repository.
   2    Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4    Contributed by Jason Merrill (jason@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* My strategy here is as follows:
  24
  25    Everything should be emitted in a translation unit where it is used.
  26    The results of the automatic process should be easily reproducible with
  27    explicit code.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "tree.h"
  34 #include "cp-tree.h"
  35 #include "input.h"
  36 #include "obstack.h"
  37 #include "toplev.h"
  38 #include "diagnostic.h"
  39
  40 static char *extract_string (char **);
  41 static const char *get_base_filename (const char *);
  42 static void open_repo_file (const char *);
  43 static char *afgets (FILE *);
  44 static void reopen_repo_file_for_write (void);
  45
  46 static GTY(()) tree pending_repo;
  47 static char *repo_name;
  48 static FILE *repo_file;
  49
  50 static const char *old_args, *old_dir, *old_main;
  51
  52 static struct obstack temporary_obstack;
  53 static bool temporary_obstack_initialized_p;
  54
  55 /* Parse a reasonable subset of shell quoting syntax.  */
  56
  57 static char *
  58 extract_string (char **pp)
  59 {
  60   char *p = *pp;
  61   int backquote = 0;
  62   int inside = 0;
  63
  64   for (;;)
  65     {
  66       char c = *p;
  67       if (c == '\0')
  68         break;
  69       ++p;
  70       if (backquote)
  71         {
  72           obstack_1grow (&temporary_obstack, c);
  73           backquote = 0;
  74         }
  75       else if (! inside && c == ' ')
  76         break;
  77       else if (! inside && c == '\\')
  78         backquote = 1;
  79       else if (c == '\'')
  80         inside = !inside;
  81       else
  82         obstack_1grow (&temporary_obstack, c);
  83     }
  84
  85   obstack_1grow (&temporary_obstack, '\0');
  86   *pp = p;
  87   return obstack_finish (&temporary_obstack);
  88 }
  89
  90 static const char *
  91 get_base_filename (const char *filename)
  92 {
  93   char *p = getenv ("COLLECT_GCC_OPTIONS");
  94   char *output = NULL;
  95   int compiling = 0;
  96
  97   while (p && *p)
  98     {
  99       char *q = extract_string (&p);
 100
 101       if (strcmp (q, "-o") == 0)
 102         output = extract_string (&p);
 103       else if (strcmp (q, "-c") == 0)
 104         compiling = 1;
 105     }
 106
 107   if (compiling && output)
 108     return output;
 109
 110   if (p && ! compiling)
 111     {
 112       warning (0, "-frepo must be used with -c");
 113       flag_use_repository = 0;
 114       return NULL;
 115     }
 116
 117   return lbasename (filename);
 118 }
 119
 120 static void
 121 open_repo_file (const char *filename)
 122 {
 123   const char *p;
 124   const char *s = get_base_filename (filename);
 125
 126   if (s == NULL)
 127     return;
 128
 129   p = lbasename (s);
 130   p = strrchr (p, '.');
 131   if (! p)
 132     p = s + strlen (s);
 133
 134   repo_name = xmalloc (p - s + 5);
 135   memcpy (repo_name, s, p - s);
 136   memcpy (repo_name + (p - s), ".rpo", 5);
 137
 138   repo_file = fopen (repo_name, "r");
 139 }
 140
 141 static char *
 142 afgets (FILE *stream)
 143 {
 144   int c;
 145   while ((c = getc (stream)) != EOF && c != '\n')
 146     obstack_1grow (&temporary_obstack, c);
 147   if (obstack_object_size (&temporary_obstack) == 0)
 148     return NULL;
 149   obstack_1grow (&temporary_obstack, '\0');
 150   return obstack_finish (&temporary_obstack);
 151 }
 152
 153 void
 154 init_repo (void)
 155 {
 156   char *buf;
 157
 158   if (! flag_use_repository)
 159     return;
 160
 161   /* When a PCH file is loaded, the entire identifier table is
 162      replaced, with the result that IDENTIFIER_REPO_CHOSEN is cleared.
 163      So, we have to reread the repository file.  */
 164   lang_post_pch_load = init_repo;
 165
 166   if (!temporary_obstack_initialized_p)
 167     gcc_obstack_init (&temporary_obstack);
 168
 169   open_repo_file (main_input_filename);
 170
 171   if (repo_file == 0)
 172     return;
 173
 174   while ((buf = afgets (repo_file)))
 175     {
 176       switch (buf[0])
 177         {
 178         case 'A':
 179           old_args = ggc_strdup (buf + 2);
 180           break;
 181         case 'D':
 182           old_dir = ggc_strdup (buf + 2);
 183           break;
 184         case 'M':
 185           old_main = ggc_strdup (buf + 2);
 186           break;
 187         case 'O':
 188           /* A symbol that we were able to define the last time this
 189              file was compiled.  */
 190           break;
 191         case 'C':
 192           /* A symbol that the prelinker has requested that we
 193              define.  */
 194           {
 195             tree id = get_identifier (buf + 2);
 196             IDENTIFIER_REPO_CHOSEN (id) = 1;
 197           }
 198           break;
 199         default:
 200           error ("mysterious repository information in %s", repo_name);
 201         }
 202       obstack_free (&temporary_obstack, buf);
 203     }
 204   fclose (repo_file);
 205 }
 206
 207 static void
 208 reopen_repo_file_for_write (void)
 209 {
 210   repo_file = fopen (repo_name, "w");
 211
 212   if (repo_file == 0)
 213     {
 214       error ("can't create repository information file %qs", repo_name);
 215       flag_use_repository = 0;
 216     }
 217 }
 218
 219 /* Emit any pending repos.  */
 220
 221 void
 222 finish_repo (void)
 223 {
 224   tree t;
 225   char *dir, *args;
 226
 227   if (!flag_use_repository)
 228     return;
 229
 230   if (errorcount || sorrycount)
 231     goto out;
 232
 233   reopen_repo_file_for_write ();
 234   if (repo_file == 0)
 235     goto out;
 236
 237   fprintf (repo_file, "M %s\n", main_input_filename);
 238   dir = getpwd ();
 239   fprintf (repo_file, "D %s\n", dir);
 240   args = getenv ("COLLECT_GCC_OPTIONS");
 241   if (args)
 242     fprintf (repo_file, "A %s\n", args);
 243
 244   for (t = pending_repo; t; t = TREE_CHAIN (t))
 245     {
 246       tree val = TREE_VALUE (t);
 247       tree name = DECL_ASSEMBLER_NAME (val);
 248       char type = IDENTIFIER_REPO_CHOSEN (name) ? 'C' : 'O';
 249       fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (name));
 250     }
 251
 252  out:
 253   if (repo_file)
 254     fclose (repo_file);
 255 }
 256
 257 /* DECL is a FUNCTION_DECL or VAR_DECL with vague linkage whose
 258    definition is available in this translation unit.  Returns 0 if
 259    this definition should not be emitted in this translation unit
 260    because it will be emitted elsewhere.  Returns 1 if the repository
 261    file indicates that that DECL should be emitted in this translation
 262    unit, or 2 if the repository file is not in use.  */
 263
 264 int
 265 repo_emit_p (tree decl)
 266 {
 267   gcc_assert (TREE_PUBLIC (decl));
 268   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
 269               || TREE_CODE (decl) == VAR_DECL);
 270   gcc_assert (!DECL_REALLY_EXTERN (decl));
 271
 272   /* When not using the repository, emit everything.  */
 273   if (!flag_use_repository)
 274     return 2;
 275
 276   /* Only template instantiations are managed by the repository.  This
 277      is an artificial restriction; the code in the prelinker and here
 278      will work fine if all entities with vague linkage are managed by
 279      the repository.  */
 280   if (TREE_CODE (decl) == VAR_DECL)
 281     {
 282       tree type = NULL_TREE;
 283       if (DECL_VTABLE_OR_VTT_P (decl))
 284         type = DECL_CONTEXT (decl);
 285       else if (DECL_TINFO_P (decl))
 286         type = TREE_TYPE (DECL_NAME (decl));
 287       if (!DECL_TEMPLATE_INSTANTIATION (decl)
 288           && !CLASSTYPE_TEMPLATE_INSTANTIATION (type))
 289         return 2;
 290     }
 291   else if (!DECL_TEMPLATE_INSTANTIATION (decl))
 292     return 2;
 293
 294   /* For constructors and destructors, the repository contains
 295      information about the clones -- not the original function --
 296      because only the clones are emitted in the object file.  */
 297   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
 298       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
 299     {
 300       int emit_p = 0;
 301       tree clone;
 302       /* There is no early exit from this loop because we want to
 303          ensure that all of the clones are marked as available in this
 304          object file.  */
 305       FOR_EACH_CLONE (clone, decl)
 306         /* The only possible results from the recursive call to
 307            repo_emit_p are 0 or 1.  */
 308         if (repo_emit_p (clone))
 309           emit_p = 1;
 310       return emit_p;
 311     }
 312
 313   /* Keep track of all available entities.  */
 314   if (!DECL_REPO_AVAILABLE_P (decl))
 315     {
 316       DECL_REPO_AVAILABLE_P (decl) = 1;
 317       pending_repo = tree_cons (NULL_TREE, decl, pending_repo);
 318     }
 319
 320   return IDENTIFIER_REPO_CHOSEN (DECL_ASSEMBLER_NAME (decl));
 321 }
 322
 323 /* Returns true iff the prelinker has explicitly marked CLASS_TYPE for
 324    export from this translation unit.  */
 325
 326 bool
 327 repo_export_class_p (tree class_type)
 328 {
 329   if (!flag_use_repository)
 330     return false;
 331   if (!CLASSTYPE_VTABLES (class_type))
 332     return false;
 333   /* If the virtual table has been assigned to this translation unit,
 334      export the class.  */
 335   return (IDENTIFIER_REPO_CHOSEN
 336           (DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (class_type))));
 337 }
 338
 339 #include "gt-cp-repo.h"