gcc/cp/repo.c

   1 /* Code to maintain a C++ template repository.
   2    Copyright (C) 1995, 1996, 1997, 1998, 2000 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
  37 static tree repo_get_id PARAMS ((tree));
  38 static char *extract_string PARAMS ((char **));
  39 static char *get_base_filename PARAMS ((const char *));
  40 static void open_repo_file PARAMS ((const char *));
  41 static char *afgets PARAMS ((FILE *));
  42 static void reopen_repo_file_for_write PARAMS ((void));
  43
  44 static tree pending_repo;
  45 static tree original_repo;
  46 static char *repo_name;
  47 static FILE *repo_file;
  48
  49 static char *old_args, *old_dir, *old_main;
  50
  51 extern int flag_use_repository;
  52 extern 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       /* If we're not done setting up the class, we may not have set up
 101          the vtable, so going ahead would give the wrong answer.
 102          See g++.pt/instantiate4.C.  */
 103       if (!COMPLETE_TYPE_P (t) || TYPE_BEING_DEFINED (t))
 104         my_friendly_abort (981113);
 105
 106       t = TYPE_BINFO_VTABLE (t);
 107       if (t == NULL_TREE)
 108         return t;
 109     }
 110   return DECL_ASSEMBLER_NAME (t);
 111 }
 112
 113 /* Note that a template has been used.  If we can see the definition, offer
 114    to emit it.  */
 115
 116 void
 117 repo_template_used (t)
 118      tree t;
 119 {
 120   tree id;
 121
 122   if (! flag_use_repository)
 123     return;
 124
 125   id = repo_get_id (t);
 126   if (id == NULL_TREE)
 127     return;
 128
 129   if (TYPE_P (t))
 130     {
 131       if (IDENTIFIER_REPO_CHOSEN (id))
 132         mark_class_instantiated (t, 0);
 133     }
 134   else if (DECL_P (t))
 135     {
 136       if (IDENTIFIER_REPO_CHOSEN (id))
 137         mark_decl_instantiated (t, 0);
 138     }
 139   else
 140     my_friendly_abort (1);
 141
 142   if (! IDENTIFIER_REPO_USED (id))
 143     {
 144       IDENTIFIER_REPO_USED (id) = 1;
 145       pending_repo = tree_cons (NULL_TREE, id, pending_repo);
 146     }
 147 }
 148
 149 #if 0
 150 /* Note that the vtable for a class has been used, and offer to emit it.  */
 151
 152 static void
 153 repo_vtable_used (t)
 154      tree t;
 155 {
 156   if (! flag_use_repository)
 157     return;
 158
 159   pending_repo = tree_cons (NULL_TREE, t, pending_repo);
 160 }
 161
 162 /* Note that an inline with external linkage has been used, and offer to
 163    emit it.  */
 164
 165 void
 166 repo_inline_used (fn)
 167      tree fn;
 168 {
 169   if (! flag_use_repository)
 170     return;
 171
 172   /* Member functions of polymorphic classes go with their vtables.  */
 173   if (DECL_FUNCTION_MEMBER_P (fn)
 174       && TYPE_POLYMORPHIC_P (DECL_CONTEXT (fn)))
 175     {
 176       repo_vtable_used (DECL_CONTEXT (fn));
 177       return;
 178     }
 179
 180   pending_repo = tree_cons (NULL_TREE, fn, pending_repo);
 181 }
 182
 183 /* Note that a particular typeinfo node has been used, and offer to
 184    emit it.  */
 185
 186 void
 187 repo_tinfo_used (ti)
 188      tree ti;
 189 {
 190 }
 191 #endif
 192
 193 void
 194 repo_template_instantiated (t, extern_p)
 195      tree t;
 196      int extern_p;
 197 {
 198   if (! extern_p)
 199     {
 200       tree id = repo_get_id (t);
 201       if (id)
 202         IDENTIFIER_REPO_CHOSEN (id) = 1;
 203     }
 204 }
 205
 206 /* Parse a reasonable subset of shell quoting syntax.  */
 207
 208 static char *
 209 extract_string (pp)
 210      char **pp;
 211 {
 212   char *p = *pp;
 213   int backquote = 0;
 214   int inside = 0;
 215
 216   for (;;)
 217     {
 218       char c = *p;
 219       if (c == '\0')
 220         break;
 221       ++p;
 222       if (backquote)
 223         obstack_1grow (&temporary_obstack, c);
 224       else if (! inside && c == ' ')
 225         break;
 226       else if (! inside && c == '\\')
 227         backquote = 1;
 228       else if (c == '\'')
 229         inside = !inside;
 230       else
 231         obstack_1grow (&temporary_obstack, c);
 232     }
 233
 234   obstack_1grow (&temporary_obstack, '\0');
 235   *pp = p;
 236   return obstack_finish (&temporary_obstack);
 237 }
 238
 239 static char *
 240 get_base_filename (filename)
 241      const char *filename;
 242 {
 243   char *p = getenv ("COLLECT_GCC_OPTIONS");
 244   char *output = NULL;
 245   int compiling = 0;
 246
 247   while (p && *p)
 248     {
 249       char *q = extract_string (&p);
 250
 251       if (strcmp (q, "-o") == 0)
 252         output = extract_string (&p);
 253       else if (strcmp (q, "-c") == 0)
 254         compiling = 1;
 255       }
 256
 257   if (compiling && output)
 258     return output;
 259
 260   if (p && ! compiling)
 261     {
 262       warning ("-frepo must be used with -c");
 263       flag_use_repository = 0;
 264       return NULL;
 265     }
 266
 267   return file_name_nondirectory (filename);
 268 }
 269
 270 static void
 271 open_repo_file (filename)
 272      const char *filename;
 273 {
 274   register const char *p;
 275   const char *s = get_base_filename (filename);
 276
 277   if (s == NULL)
 278     return;
 279
 280   p = file_name_nondirectory (s);
 281   p = rindex (p, '.');
 282   if (! p)
 283     p = s + strlen (s);
 284
 285   obstack_grow (&permanent_obstack, s, p - s);
 286   repo_name = obstack_copy0 (&permanent_obstack, ".rpo", 4);
 287
 288   repo_file = fopen (repo_name, "r");
 289 }
 290
 291 static char *
 292 afgets (stream)
 293      FILE *stream;
 294 {
 295   int c;
 296   while ((c = getc (stream)) != EOF && c != '\n')
 297     obstack_1grow (&temporary_obstack, c);
 298   if (obstack_object_size (&temporary_obstack) == 0)
 299     return NULL;
 300   obstack_1grow (&temporary_obstack, '\0');
 301   return obstack_finish (&temporary_obstack);
 302 }
 303
 304 void
 305 init_repo (filename)
 306      const char *filename;
 307 {
 308   char *buf;
 309
 310   if (! flag_use_repository)
 311     return;
 312
 313   ggc_add_tree_root (&pending_repo, 1);
 314   ggc_add_tree_root (&original_repo, 1);
 315
 316   open_repo_file (filename);
 317
 318   if (repo_file == 0)
 319     return;
 320
 321   while ((buf = afgets (repo_file)))
 322     {
 323       switch (buf[0])
 324         {
 325         case 'A':
 326           old_args = obstack_copy0 (&permanent_obstack, buf + 2,
 327                                     strlen (buf + 2));
 328           break;
 329         case 'D':
 330           old_dir = obstack_copy0 (&permanent_obstack, buf + 2,
 331                                    strlen (buf + 2));
 332           break;
 333         case 'M':
 334           old_main = obstack_copy0 (&permanent_obstack, buf + 2,
 335                                     strlen (buf + 2));
 336           break;
 337         case 'C':
 338         case 'O':
 339           {
 340             tree id = get_identifier (buf + 2);
 341             tree orig;
 342
 343             if (buf[0] == 'C')
 344               {
 345                 IDENTIFIER_REPO_CHOSEN (id) = 1;
 346                 orig = integer_one_node;
 347               }
 348             else
 349               orig = NULL_TREE;
 350
 351             original_repo = tree_cons (orig, id, original_repo);
 352           }
 353           break;
 354         default:
 355           error ("mysterious repository information in %s", repo_name);
 356         }
 357       obstack_free (&temporary_obstack, buf);
 358     }
 359 }
 360
 361 static void
 362 reopen_repo_file_for_write ()
 363 {
 364   if (repo_file)
 365     fclose (repo_file);
 366   repo_file = fopen (repo_name, "w");
 367
 368   if (repo_file == 0)
 369     {
 370       error ("can't create repository information file `%s'", repo_name);
 371       flag_use_repository = 0;
 372     }
 373 }
 374
 375 /* Emit any pending repos.  */
 376
 377 void
 378 finish_repo ()
 379 {
 380   tree t;
 381   int repo_changed = 0;
 382   char *dir, *args;
 383
 384   if (! flag_use_repository)
 385     return;
 386
 387   /* Do we have to write out a new info file?  */
 388
 389   /* Are there any old templates that aren't used any longer or that are
 390      newly chosen?  */
 391
 392   for (t = original_repo; t; t = TREE_CHAIN (t))
 393     {
 394       if (! IDENTIFIER_REPO_USED (TREE_VALUE (t))
 395           || (! TREE_PURPOSE (t) && IDENTIFIER_REPO_CHOSEN (TREE_VALUE (t))))
 396         {
 397           repo_changed = 1;
 398           break;
 399         }
 400       IDENTIFIER_REPO_USED (TREE_VALUE (t)) = 0;
 401     }
 402
 403   /* Are there any templates that are newly used?  */
 404
 405   if (! repo_changed)
 406     for (t = pending_repo; t; t = TREE_CHAIN (t))
 407       {
 408         if (IDENTIFIER_REPO_USED (TREE_VALUE (t)))
 409           {
 410             repo_changed = 1;
 411             break;
 412           }
 413       }
 414
 415   dir = getpwd ();
 416   args = getenv ("COLLECT_GCC_OPTIONS");
 417
 418   if (! repo_changed && pending_repo)
 419     if (strcmp (old_main, main_input_filename) != 0
 420         || strcmp (old_dir, dir) != 0
 421         || (args == NULL) != (old_args == NULL)
 422         || (args && strcmp (old_args, args) != 0))
 423       repo_changed = 1;
 424
 425   if (! repo_changed || errorcount || sorrycount)
 426     goto out;
 427
 428   reopen_repo_file_for_write ();
 429
 430   if (repo_file == 0)
 431     goto out;
 432
 433   fprintf (repo_file, "M %s\n", main_input_filename);
 434   fprintf (repo_file, "D %s\n", dir);
 435   if (args)
 436     fprintf (repo_file, "A %s\n", args);
 437
 438   for (t = pending_repo; t; t = TREE_CHAIN (t))
 439     {
 440       tree val = TREE_VALUE (t);
 441       char type = IDENTIFIER_REPO_CHOSEN (val) ? 'C' : 'O';
 442
 443       fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (val));
 444     }
 445
 446  out:
 447   if (repo_file)
 448     fclose (repo_file);
 449 }