1 /* Code to maintain a C++ template repository. 2 Copyright (C) 1995-2015 Free Software Foundation, Inc. 3 Contributed by Jason Merrill (jason@cygnus.com) 4 5 This file is part of GCC. 6 7 GCC 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 3, or (at your option) 10 any later version. 11 12 GCC 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 GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 /* My strategy here is as follows: 22 23 Everything should be emitted in a translation unit where it is used. 24 The results of the automatic process should be easily reproducible with 25 explicit code. */ 26 27 #include "config.h" 28 #include "system.h" 29 #include "coretypes.h" 30 #include "tm.h" 31 #include "hash-set.h" 32 #include "machmode.h" 33 #include "vec.h" 34 #include "double-int.h" 35 #include "input.h" 36 #include "alias.h" 37 #include "symtab.h" 38 #include "wide-int.h" 39 #include "inchash.h" 40 #include "tree.h" 41 #include "stringpool.h" 42 #include "cp-tree.h" 43 #include "input.h" 44 #include "obstack.h" 45 #include "toplev.h" 46 #include "diagnostic-core.h" 47 #include "flags.h" 48 49 static const char *extract_string (const char **); 50 static const char *get_base_filename (const char *); 51 static FILE *open_repo_file (const char *); 52 static char *afgets (FILE *); 53 static FILE *reopen_repo_file_for_write (void); 54 55 static GTY(()) vec<tree, va_gc> *pending_repo; 56 static char *repo_name; 57 58 static const char *old_args, *old_dir, *old_main; 59 60 static struct obstack temporary_obstack; 61 static bool temporary_obstack_initialized_p; 62 63 /* Parse a reasonable subset of shell quoting syntax. */ 64 65 static const char * 66 extract_string (const char **pp) 67 { 68 const char *p = *pp; 69 int backquote = 0; 70 int inside = 0; 71 72 for (;;) 73 { 74 char c = *p; 75 if (c == '\0') 76 break; 77 ++p; 78 if (backquote) 79 { 80 obstack_1grow (&temporary_obstack, c); 81 backquote = 0; 82 } 83 else if (! inside && c == ' ') 84 break; 85 else if (! inside && c == '\\') 86 backquote = 1; 87 else if (c == '\'') 88 inside = !inside; 89 else 90 obstack_1grow (&temporary_obstack, c); 91 } 92 93 obstack_1grow (&temporary_obstack, '\0'); 94 *pp = p; 95 return (char *) obstack_finish (&temporary_obstack); 96 } 97 98 static const char * 99 get_base_filename (const char *filename) 100 { 101 const char *p = getenv ("COLLECT_GCC_OPTIONS"); 102 const char *output = NULL; 103 int compiling = 0; 104 105 while (p && *p) 106 { 107 const char *q = extract_string (&p); 108 109 if (strcmp (q, "-o") == 0) 110 { 111 if (flag_compare_debug) 112 /* Just in case aux_base_name was based on a name with two 113 or more '.'s, add an arbitrary extension that will be 114 stripped by the caller. */ 115 output = concat (aux_base_name, ".o", NULL); 116 else 117 output = extract_string (&p); 118 } 119 else if (strcmp (q, "-c") == 0) 120 compiling = 1; 121 } 122 123 if (compiling && output) 124 return output; 125 126 if (p && ! compiling) 127 { 128 warning (0, "-frepo must be used with -c"); 129 flag_use_repository = 0; 130 return NULL; 131 } 132 133 return lbasename (filename); 134 } 135 136 static FILE * 137 open_repo_file (const char *filename) 138 { 139 const char *p; 140 const char *s = get_base_filename (filename); 141 142 if (s == NULL) 143 return NULL; 144 145 p = lbasename (s); 146 p = strrchr (p, '.'); 147 if (! p) 148 p = s + strlen (s); 149 150 repo_name = XNEWVEC (char, p - s + 5); 151 memcpy (repo_name, s, p - s); 152 memcpy (repo_name + (p - s), ".rpo", 5); 153 154 return fopen (repo_name, "r"); 155 } 156 157 static char * 158 afgets (FILE *stream) 159 { 160 int c; 161 while ((c = getc (stream)) != EOF && c != '\n') 162 obstack_1grow (&temporary_obstack, c); 163 if (obstack_object_size (&temporary_obstack) == 0) 164 return NULL; 165 obstack_1grow (&temporary_obstack, '\0'); 166 return (char *) obstack_finish (&temporary_obstack); 167 } 168 169 void 170 init_repo (void) 171 { 172 char *buf; 173 const char *p; 174 FILE *repo_file; 175 176 if (! flag_use_repository) 177 return; 178 179 /* When a PCH file is loaded, the entire identifier table is 180 replaced, with the result that IDENTIFIER_REPO_CHOSEN is cleared. 181 So, we have to reread the repository file. */ 182 lang_post_pch_load = init_repo; 183 184 if (!temporary_obstack_initialized_p) 185 gcc_obstack_init (&temporary_obstack); 186 187 repo_file = open_repo_file (main_input_filename); 188 189 if (repo_file == 0) 190 return; 191 192 while ((buf = afgets (repo_file))) 193 { 194 switch (buf[0]) 195 { 196 case 'A': 197 old_args = ggc_strdup (buf + 2); 198 break; 199 case 'D': 200 old_dir = ggc_strdup (buf + 2); 201 break; 202 case 'M': 203 old_main = ggc_strdup (buf + 2); 204 break; 205 case 'O': 206 /* A symbol that we were able to define the last time this 207 file was compiled. */ 208 break; 209 case 'C': 210 /* A symbol that the prelinker has requested that we 211 define. */ 212 { 213 tree id = get_identifier (buf + 2); 214 IDENTIFIER_REPO_CHOSEN (id) = 1; 215 } 216 break; 217 default: 218 error ("mysterious repository information in %s", repo_name); 219 } 220 obstack_free (&temporary_obstack, buf); 221 } 222 fclose (repo_file); 223 224 if (old_args && !get_random_seed (true) 225 && (p = strstr (old_args, "'-frandom-seed="))) 226 set_random_seed (extract_string (&p) + strlen ("-frandom-seed=")); 227 } 228 229 static FILE * 230 reopen_repo_file_for_write (void) 231 { 232 FILE *repo_file = fopen (repo_name, "w"); 233 234 if (repo_file == 0) 235 { 236 error ("can%'t create repository information file %qs", repo_name); 237 flag_use_repository = 0; 238 } 239 240 return repo_file; 241 } 242 243 /* Emit any pending repos. */ 244 245 void 246 finish_repo (void) 247 { 248 tree val; 249 char *dir, *args; 250 FILE *repo_file; 251 unsigned ix; 252 253 if (!flag_use_repository || flag_compare_debug) 254 return; 255 256 if (seen_error ()) 257 return; 258 259 repo_file = reopen_repo_file_for_write (); 260 if (repo_file == 0) 261 goto out; 262 263 fprintf (repo_file, "M %s\n", main_input_filename); 264 dir = getpwd (); 265 fprintf (repo_file, "D %s\n", dir); 266 args = getenv ("COLLECT_GCC_OPTIONS"); 267 if (args) 268 { 269 fprintf (repo_file, "A %s", args); 270 /* If -frandom-seed is not among the ARGS, then add the value 271 that we chose. That will ensure that the names of types from 272 anonymous namespaces will get the same mangling when this 273 file is recompiled. */ 274 if (!strstr (args, "'-frandom-seed=")) 275 fprintf (repo_file, " '-frandom-seed=" HOST_WIDE_INT_PRINT_HEX_PURE "'", 276 get_random_seed (false)); 277 fprintf (repo_file, "\n"); 278 } 279 280 FOR_EACH_VEC_SAFE_ELT_REVERSE (pending_repo, ix, val) 281 { 282 tree name = DECL_ASSEMBLER_NAME (val); 283 char type = IDENTIFIER_REPO_CHOSEN (name) ? 'C' : 'O'; 284 fprintf (repo_file, "%c %s\n", type, IDENTIFIER_POINTER (name)); 285 } 286 287 out: 288 if (repo_file) 289 fclose (repo_file); 290 } 291 292 /* DECL is a FUNCTION_DECL or VAR_DECL with vague linkage whose 293 definition is available in this translation unit. Returns 0 if 294 this definition should not be emitted in this translation unit 295 because it will be emitted elsewhere. Returns 1 if the repository 296 file indicates that that DECL should be emitted in this translation 297 unit, or 2 if the repository file is not in use. */ 298 299 int 300 repo_emit_p (tree decl) 301 { 302 int ret = 0; 303 gcc_assert (TREE_PUBLIC (decl)); 304 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 305 gcc_assert (!DECL_REALLY_EXTERN (decl) 306 /* A clone might not have its linkage flags updated yet 307 because we call import_export_decl before 308 maybe_clone_body. */ 309 || DECL_ABSTRACT_ORIGIN (decl)); 310 311 /* When not using the repository, emit everything. */ 312 if (!flag_use_repository) 313 return 2; 314 315 /* Only template instantiations are managed by the repository. This 316 is an artificial restriction; the code in the prelinker and here 317 will work fine if all entities with vague linkage are managed by 318 the repository. */ 319 if (VAR_P (decl)) 320 { 321 tree type = NULL_TREE; 322 if (DECL_VTABLE_OR_VTT_P (decl)) 323 type = DECL_CONTEXT (decl); 324 else if (DECL_TINFO_P (decl)) 325 type = TREE_TYPE (DECL_NAME (decl)); 326 if (!DECL_TEMPLATE_INSTANTIATION (decl) 327 && (!TYPE_LANG_SPECIFIC (type) 328 || !CLASSTYPE_TEMPLATE_INSTANTIATION (type))) 329 return 2; 330 /* Const static data members initialized by constant expressions must 331 be processed where needed so that their definitions are 332 available. Still record them into *.rpo files, so if they 333 weren't actually emitted and collect2 requests them, they can 334 be provided. */ 335 if (decl_maybe_constant_var_p (decl) 336 && DECL_CLASS_SCOPE_P (decl)) 337 ret = 2; 338 } 339 else if (!DECL_TEMPLATE_INSTANTIATION (decl)) 340 return 2; 341 342 if (DECL_EXPLICIT_INSTANTIATION (decl)) 343 return 2; 344 345 /* For constructors and destructors, the repository contains 346 information about the clones -- not the original function -- 347 because only the clones are emitted in the object file. */ 348 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl) 349 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)) 350 { 351 int emit_p = 0; 352 tree clone; 353 /* There is no early exit from this loop because we want to 354 ensure that all of the clones are marked as available in this 355 object file. */ 356 FOR_EACH_CLONE (clone, decl) 357 /* The only possible results from the recursive call to 358 repo_emit_p are 0 or 1. */ 359 if (repo_emit_p (clone)) 360 emit_p = 1; 361 return emit_p; 362 } 363 364 /* Keep track of all available entities. */ 365 if (!DECL_REPO_AVAILABLE_P (decl)) 366 { 367 DECL_REPO_AVAILABLE_P (decl) = 1; 368 vec_safe_push (pending_repo, decl); 369 } 370 371 return IDENTIFIER_REPO_CHOSEN (DECL_ASSEMBLER_NAME (decl)) ? 1 : ret; 372 } 373 374 /* Returns true iff the prelinker has explicitly marked CLASS_TYPE for 375 export from this translation unit. */ 376 377 bool 378 repo_export_class_p (const_tree class_type) 379 { 380 if (!flag_use_repository) 381 return false; 382 if (!CLASSTYPE_VTABLES (class_type)) 383 return false; 384 /* If the virtual table has been assigned to this translation unit, 385 export the class. */ 386 return (IDENTIFIER_REPO_CHOSEN 387 (DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (class_type)))); 388 } 389 390 #include "gt-cp-repo.h" 391