gcc/cp/repo.c

   1 /* Code to maintain a C++ template repository.
   2    Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
   3    Contributed by Jason Merrill (jason@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* My strategy here is as follows:
  23
  24    Everything should be emitted in a translation unit where it is used.
  25    The results of the automatic process should be easily reproducible with
  26    explicit code.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "tree.h"
  31 #include "cp-tree.h"
  32 #include "input.h"
  33 #include "obstack.h"
  34 #include "toplev.h"
  35 #include "ggc.h"
  36 #include "diagnostic.h"
  37
  38 static tree repo_get_id PARAMS ((tree));
  39 static char *extract_string PARAMS ((char **));
  40 static const char *get_base_filename PARAMS ((const char *));
  41 static void open_repo_file PARAMS ((const char *));
  42 static char *afgets PARAMS ((FILE *));
  43 static void reopen_repo_file_for_write PARAMS ((void));
  44
  45 static tree pending_repo;
  46 static tree original_repo;
  47 static char *repo_name;
  48 static FILE *repo_file;
  49
  50 static char *old_args, *old_dir, *old_main;
  51
  52 static struct obstack temporary_obstack;
  53 extern struct obstack permanent_obstack;
  54
  55 #define IDENTIFIER_REPO_USED(NODE)   (TREE_LANG_FLAG_3 (NODE))
  56 #define IDENTIFIER_REPO_CHOSEN(NODE) (TREE_LANG_FLAG_4 (NODE))
  57
  58 #if 0
  59 /* Record the flags used to compile this translation unit.  */
  60
  61 void
  62 repo_compile_flags (argc, argv)
  63      int argc;
  64      char **argv;
  65 {
  66 }
  67
  68 /* If this template has not been seen before, add a note to the repository
  69    saying where the declaration was.  This may be used to find the
  70    definition at link time.  */
  71
  72 void
  73 repo_template_declared (t)
  74      tree t;
  75 {}
  76
  77 /* Note where the definition of a template lives so that instantiations can
  78    be generated later.  */
  79
  80 void
  81 repo_template_defined (t)
  82      tree t;
  83 {}
  84
  85 /* Note where the definition of a class lives to that template
  86    instantiations can use it.  */
  87
  88 void
  89 repo_class_defined (t)
  90      tree t;
  91 {}
  92 #endif
  93
  94 static tree
  95 repo_get_id (t)
  96      tree t;
  97 {
  98   if (TYPE_P (t))
  99     {
 100       tree vtable;
 101
 102       /* If we're not done setting up the class, we may not have set up
 103          the vtable, so going ahead would give the wrong answer.
 104          See g++.pt/instantiate4.C.  */
 105       if (!COMPLETE_TYPE_P (t) || TYPE_BEING_DEFINED (t))
 106         abort ();
 107
 108       vtable = get_vtbl_decl_for_binfo (TYPE_BINFO (t));
 109
 110       t = vtable;
 111       if (t == NULL_TREE)
 112         return t;
 113     }
 114   return DECL_ASSEMBLER_NAME (t);
 115 }
 116
 117 /* Note that a template has been used.  If we can see the definition, offer
 118    to emit it.  */
 119
 120 void
 121 repo_template_used (t)
 122      tree t;
 123 {
 124   tree id;
 125
 126   if (! flag_use_repository)
 127     return;
 128
 129   id = repo_get_id (t);
 130   if (id == NULL_TREE)
 131     return;
 132
 133   if (TYPE_P (t))
 134     {
 135       if (IDENTIFIER_REPO_CHOSEN (id))
 136         mark_class_instantiated (t, 0);
 137     }
 138   else if (DECL_P (t))
 139     {
 140       if (IDENTIFIER_REPO_CHOSEN (id))
 141         /* It doesn't make sense to instantiate a clone, so we
 142            instantiate the cloned function instead.  Note that this
 143            approach will not work correctly if collect2 assigns
 144            different clones to different files -- but it shouldn't.  */
 145         mark_decl_instantiated (DECL_CLONED_FUNCTION_P (t)
 146                                 ? DECL_CLONED_FUNCTION (t) : t,
 147                                 0);
 148     }
 149   else
 150     abort ();
 151
 152   if (! IDENTIFIER_REPO_USED (id))
 153     {
 154       IDENTIFIER_REPO_USED (id) = 1;
 155       pending_repo = tree_cons (NULL_TREE, id, pending_repo);
 156     }
 157 }
 158
 159 #if 0
 160 /* Note that the vtable for a class has been used, and offer to emit it.  */
 161
 162 static void
 163 repo_vtable_used (t)
 164      tree t;
 165 {
 166   if (! flag_use_repository)
 167     return;
 168
 169   pending_repo = tree_cons (NULL_TREE, t, pending_repo);
 170 }
 171
 172 /* Note that an inline with external linkage has been used, and offer to
 173    emit it.  */
 174
 175 void
 176 repo_inline_used (fn)
 177      tree fn;
 178 {
 179   if (! flag_use_repository)
 180     return;
 181
 182   /* Member functions of polymorphic classes go with their vtables.  */
 183   if (DECL_FUNCTION_MEMBER_P (fn)
 184       && TYPE_POLYMORPHIC_P (DECL_CONTEXT (fn)))
 185     {
 186       repo_vtable_used (DECL_CONTEXT (fn));
 187       return;
 188     }
 189
 190   pending_repo = tree_cons (NULL_TREE, fn, pending_repo);
 191 }
 192
 193 /* Note that a particular typeinfo node has been used, and offer to
 194    emit it.  */
 195
 196 void
 197 repo_tinfo_used (ti)
 198      tree ti;
 199 {
 200 }
 201 #endif
 202
 203 void
 204 repo_template_instantiated (t, extern_p)
 205      tree t;
 206      int extern_p;
 207 {
 208   if (! extern_p)
 209     {
 210       tree id = repo_get_id (t);
 211       if (id)
 212         IDENTIFIER_REPO_CHOSEN (id) = 1;
 213     }
 214 }
 215
 216 /* Parse a reasonable subset of shell quoting syntax.  */
 217
 218 static char *
 219 extract_string (pp)
 220      char **pp;
 221 {
 222   char *p = *pp;
 223   int backquote = 0;
 224   int inside = 0;
 225
 226   for (;;)
 227     {
 228       char c = *p;
 229       if (c == '\0')
 230         break;
 231       ++p;
 232       if (backquote)
 233         obstack_1grow (&temporary_obstack, c);
 234       else if (! inside && c == ' ')
 235         break;
 236       else if (! inside && c == '\\')
 237         backquote = 1;
 238       else if (c == '\'')
 239         inside = !inside;
 240       else
 241         obstack_1grow (&temporary_obstack, c);
 242     }
 243
 244   obstack_1grow (&temporary_obstack, '\0');
 245   *pp = p;
 246   return obstack_finish (&temporary_obstack);
 247 }
 248
 249 const char *
 250 get_base_filename (filename)
 251      const char *filename;
 252 {
 253   char *p = getenv ("COLLECT_GCC_OPTIONS");
 254   char *output = NULL;
 255   int compiling = 0;
 256
 257   while (p && *p)
 258     {
 259       char *q = extract_string (&p);
 260
 261       if (strcmp (q, "-o") == 0)
 262         output = extract_string (&p);
 263       else if (strcmp (q, "-c") == 0)
 264         compiling = 1;
 265       }
 266
 267   if (compiling && output)
 268     return output;
 269
 270   if (p && ! compiling)
 271     {
 272       warning ("-frepo must be used with -c");
 273       flag_use_repository = 0;
 274       return NULL;
 275     }
 276
 277   return lbasename (filename);
 278 }
 279
 280 static void
 281 open_repo_file (filename)
 282      const char *filename;
 283 {
 284   register const char *p;
 285   const char *s = get_base_filename (filename);
 286
 287   if (s == NULL)
 288     return;
 289
 290   p = lbasename (s);
 291   p = strrchr (p, '.');
 292   if (! p)
 293     p = s + strlen (s);
 294
 295   obstack_grow (&permanent_obstack, s, p - s);
 296   repo_name = obstack_copy0 (&permanent_obstack, ".rpo", 4);
 297
 298   repo_file = fopen (repo_name, "r");
 299 }
 300
 301 static char *
 302 afgets (stream)
 303      FILE *stream;
 304 {
 305   int c;
 306   while ((c = getc (stream)) != EOF && c != '\n')
 307     obstack_1grow (&temporary_obstack, c);
 308   if (obstack_object_size (&temporary_obstack) == 0)
 309     return NULL;
 310   obstack_1grow (&temporary_obstack, '\0');
 311   return obstack_finish (&temporary_obstack);
 312 }
 313
 314 void
 315 init_repo (filename)
 316      const char *filename;
 317 {
 318   char *buf;
 319
 320   if (! flag_use_repository)
 321     return;
 322
 323   ggc_add_tree_root (&pending_repo, 1);
 324   ggc_add_tree_root (&original_repo, 1);
 325   gcc_obstack_init (&temporary_obstack);
 326
 327   open_repo_file (filename);
 328
 329   if (repo_file == 0)
 330     return;
 331
 332   while ((buf = afgets (repo_file)))
 333     {
 334       switch (buf[0])
 335         {
 336         case 'A':
 337           old_args = obstack_copy0 (&permanent_obstack, buf + 2,
 338                                     strlen (buf + 2));
 339           break;
 340         case 'D':
 341           old_dir = obstack_copy0 (&permanent_obstack, buf + 2,
 342                                    strlen (buf + 2));
 343           break;
 344         case 'M':
 345           old_main = obstack_copy0 (&permanent_obstack, buf + 2,
 346                                     strlen (buf + 2));
 347           break;
 348         case 'C':
 349         case 'O':
 350           {
 351             tree id = get_identifier (buf + 2);
 352             tree orig;
 353
 354             if (buf[0] == 'C')
 355               {
 356                 IDENTIFIER_REPO_CHOSEN (id) = 1;
 357                 orig = integer_one_node;
 358               }
 359             else
 360               orig = NULL_TREE;
 361
 362             original_repo = tree_cons (orig, id, original_repo);
 363           }
 364           break;
 365         default:
 366           error ("mysterious repository information in %s", repo_name);
 367         }
 368       obstack_free (&temporary_obstack, buf);
 369     }
 370 }
 371
 372 static void
 373 reopen_repo_file_for_write ()
 374 {
 375   if (repo_file)
 376     fclose (repo_file);
 377   repo_file = fopen (repo_name, "w");
 378
 379   if (repo_file == 0)
 380     {
 381       error ("can't create repository information file `%s'", repo_name);
 382       flag_use_repository = 0;
 383     }
 384 }
 385
 386 /* Emit any pending repos.  */
 387
 388 void
 389 finish_repo ()
 390 {
 391   tree t;
 392   int repo_changed = 0;
 393   char *dir, *args;
 394
 395   if (! flag_use_repository)
 396     return;
 397
 398   /* Do we have to write out a new info file?  */
 399
 400   /* Are there any old templates that aren't used any longer or that are
 401      newly chosen?  */
 402
 403   for (t = original_repo; t; t = TREE_CHAIN (t))
 404     {
 405       if (! IDENTIFIER_REPO_USED (TREE_VALUE (t))
 406           || (! TREE_PURPOSE (t) && IDENTIFIER_REPO_CHOSEN (TREE_VALUE (t))))
 407         {
 408           repo_changed = 1;
 409           break;
 410         }
 411       IDENTIFIER_REPO_USED (TREE_VALUE (t)) = 0;
 412     }
 413
 414   /* Are there any templates that are newly used?  */
 415
 416   if (! repo_changed)
 417     for (t = pending_repo; t; t = TREE_CHAIN (t))
 418       {
 419         if (IDENTIFIER_REPO_USED (TREE_VALUE (t)))
 420           {
 421             repo_changed = 1;
 422             break;
 423           }
 424       }
 425
 426   dir = getpwd ();
 427   args = getenv ("COLLECT_GCC_OPTIONS");
 428
 429   if (! repo_changed && pending_repo)
 430     if (strcmp (old_main, main_input_filename) != 0
 431         || strcmp (old_dir, dir) != 0
 432         || (args == NULL) != (old_args == NULL)
 433         || (args && strcmp (old_args, args) != 0))
 434       repo_changed = 1;
 435
 436   if (! repo_changed || errorcount || sorrycount)
 437     goto out;
 438
 439   reopen_repo_file_for_write ();
 440
 441   if (repo_file == 0)
 442     goto out;
 443
 444   fprintf (repo_file, "M %s\n", main_input_filename);
 445   fprintf (repo_file, "D %s\n", dir);
 446   if (args)
 447     fprintf (repo_file, "A %s\n", args);
 448
 449   for (t = pending_repo; t; t = TREE_CHAIN (t))
 450     {
 451       tree val = TREE_VALUE (t);
 452       char type = IDENTIFIER_REPO_CHOSEN (val) ? 'C' : 'O';
 453
 454       fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (val));
 455     }
 456
 457  out:
 458   if (repo_file)
 459     fclose (repo_file);
 460 }