c-pch.c revision 169690
1204962Srdivacky/* Precompiled header implementation for the C languages. 2204962Srdivacky Copyright (C) 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3204962Srdivacky 4204962SrdivackyThis file is part of GCC. 5204962Srdivacky 6204962SrdivackyGCC is free software; you can redistribute it and/or modify 7204962Srdivackyit under the terms of the GNU General Public License as published by 8204962Srdivackythe Free Software Foundation; either version 2, or (at your option) 9204962Srdivackyany later version. 10204962Srdivacky 11204962SrdivackyGCC is distributed in the hope that it will be useful, 12204962Srdivackybut WITHOUT ANY WARRANTY; without even the implied warranty of 13204962SrdivackyMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14204962SrdivackyGNU General Public License for more details. 15204962Srdivacky 16226633SdimYou should have received a copy of the GNU General Public License 17204962Srdivackyalong with GCC; see the file COPYING. If not, write to 18204962Srdivackythe Free Software Foundation, 51 Franklin Street, Fifth Floor, 19204962SrdivackyBoston, MA 02110-1301, USA. */ 20204962Srdivacky 21204962Srdivacky#include "config.h" 22204962Srdivacky#include "system.h" 23212904Sdim#include "coretypes.h" 24204962Srdivacky#include "version.h" 25212904Sdim#include "cpplib.h" 26212904Sdim#include "tree.h" 27204962Srdivacky#include "flags.h" 28204962Srdivacky#include "c-common.h" 29204962Srdivacky#include "output.h" 30204962Srdivacky#include "toplev.h" 31218893Sdim#include "debug.h" 32218893Sdim#include "c-pragma.h" 33218893Sdim#include "ggc.h" 34218893Sdim#include "langhooks.h" 35239462Sdim#include "hosthooks.h" 36204962Srdivacky#include "target.h" 37204962Srdivacky 38204962Srdivacky/* This is a list of flag variables that must match exactly, and their 39204962Srdivacky names for the error message. The possible values for *flag_var must 40204962Srdivacky fit in a 'signed char'. */ 41204962Srdivacky 42204962Srdivackystatic const struct c_pch_matching 43204962Srdivacky{ 44218893Sdim int *flag_var; 45218893Sdim const char *flag_name; 46263508Sdim} pch_matching[] = { 47263508Sdim { &flag_exceptions, "-fexceptions" }, 48234353Sdim { &flag_unit_at_a_time, "-funit-at-a-time" } 49205219Srdivacky}; 50205219Srdivacky 51218893Sdimenum { 52218893Sdim MATCH_SIZE = ARRAY_SIZE (pch_matching) 53218893Sdim}; 54208600Srdivacky 55218893Sdim/* The value of the checksum in the dummy compiler that is actually 56263508Sdim checksummed. That compiler should never be run. */ 57263508Sdimstatic const char no_checksum[16] = { 0 }; 58205219Srdivacky 59239462Sdim/* Information about flags and suchlike that affect PCH validity. 60239462Sdim 61204962Srdivacky Before this structure is read, both an initial 8-character identification 62204962Srdivacky string, and a 16-byte checksum, have been read and validated. */ 63204962Srdivacky 64204962Srdivackystruct c_pch_validity 65204962Srdivacky{ 66204962Srdivacky unsigned char debug_info_type; 67204962Srdivacky signed char match[MATCH_SIZE]; 68218893Sdim void (*pch_init) (void); 69218893Sdim size_t target_data_length; 70204962Srdivacky}; 71204962Srdivacky 72208600Srdivackystruct c_pch_header 73205219Srdivacky{ 74205219Srdivacky unsigned long asm_size; 75239462Sdim}; 76226633Sdim 77263508Sdim#define IDENT_LENGTH 8 78263508Sdim 79263508Sdim/* The file we'll be writing the PCH to. */ 80205219Srdivackystatic FILE *pch_outfile; 81263508Sdim 82205219Srdivacky/* The position in the assembler output file when pch_init was called. */ 83205219Srdivackystatic long asm_file_startpos; 84226633Sdim 85249423Sdimstatic const char *get_ident (void); 86249423Sdim 87249423Sdim/* Compute an appropriate 8-byte magic number for the PCH file, so that 88226633Sdim utilities like file(1) can identify it, and so that GCC can quickly 89226633Sdim ignore non-PCH files and PCH files that are of a completely different 90239462Sdim format. */ 91205219Srdivacky 92226633Sdimstatic const char * 93205219Srdivackyget_ident (void) 94205219Srdivacky{ 95204962Srdivacky static char result[IDENT_LENGTH]; 96 static const char template[IDENT_LENGTH] = "gpch.013"; 97 static const char c_language_chars[] = "Co+O"; 98 99 memcpy (result, template, IDENT_LENGTH); 100 result[4] = c_language_chars[c_language]; 101 102 return result; 103} 104 105/* Prepare to write a PCH file, if one is being written. This is 106 called at the start of compilation. 107 108 Also, print out the executable checksum if -fverbose-asm is in effect. */ 109 110void 111pch_init (void) 112{ 113 FILE *f; 114 struct c_pch_validity v; 115 void *target_validity; 116 static const char partial_pch[IDENT_LENGTH] = "gpcWrite"; 117 118#ifdef ASM_COMMENT_START 119 if (flag_verbose_asm) 120 { 121 fprintf (asm_out_file, "%s ", ASM_COMMENT_START); 122 c_common_print_pch_checksum (asm_out_file); 123 fputc ('\n', asm_out_file); 124 } 125#endif 126 127 if (!pch_file) 128 return; 129 130 f = fopen (pch_file, "w+b"); 131 if (f == NULL) 132 fatal_error ("can%'t create precompiled header %s: %m", pch_file); 133 pch_outfile = f; 134 135 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0); 136 137 v.debug_info_type = write_symbols; 138 { 139 size_t i; 140 for (i = 0; i < MATCH_SIZE; i++) 141 { 142 v.match[i] = *pch_matching[i].flag_var; 143 gcc_assert (v.match[i] == *pch_matching[i].flag_var); 144 } 145 } 146 v.pch_init = &pch_init; 147 target_validity = targetm.get_pch_validity (&v.target_data_length); 148 149 if (fwrite (partial_pch, IDENT_LENGTH, 1, f) != 1 150 || fwrite (executable_checksum, 16, 1, f) != 1 151 || fwrite (&v, sizeof (v), 1, f) != 1 152 || fwrite (target_validity, v.target_data_length, 1, f) != 1) 153 fatal_error ("can%'t write to %s: %m", pch_file); 154 155 /* We need to be able to re-read the output. */ 156 /* The driver always provides a valid -o option. */ 157 if (asm_file_name == NULL 158 || strcmp (asm_file_name, "-") == 0) 159 fatal_error ("%qs is not a valid output file", asm_file_name); 160 161 asm_file_startpos = ftell (asm_out_file); 162 163 /* Let the debugging format deal with the PCHness. */ 164 (*debug_hooks->handle_pch) (0); 165 166 cpp_save_state (parse_in, f); 167} 168 169/* Write the PCH file. This is called at the end of a compilation which 170 will produce a PCH file. */ 171 172void 173c_common_write_pch (void) 174{ 175 char *buf; 176 long asm_file_end; 177 long written; 178 struct c_pch_header h; 179 180 (*debug_hooks->handle_pch) (1); 181 182 cpp_write_pch_deps (parse_in, pch_outfile); 183 184 asm_file_end = ftell (asm_out_file); 185 h.asm_size = asm_file_end - asm_file_startpos; 186 187 if (fwrite (&h, sizeof (h), 1, pch_outfile) != 1) 188 fatal_error ("can%'t write %s: %m", pch_file); 189 190 buf = XNEWVEC (char, 16384); 191 192 if (fseek (asm_out_file, asm_file_startpos, SEEK_SET) != 0) 193 fatal_error ("can%'t seek in %s: %m", asm_file_name); 194 195 for (written = asm_file_startpos; written < asm_file_end; ) 196 { 197 long size = asm_file_end - written; 198 if (size > 16384) 199 size = 16384; 200 if (fread (buf, size, 1, asm_out_file) != 1) 201 fatal_error ("can%'t read %s: %m", asm_file_name); 202 if (fwrite (buf, size, 1, pch_outfile) != 1) 203 fatal_error ("can%'t write %s: %m", pch_file); 204 written += size; 205 } 206 free (buf); 207 /* asm_out_file can be written afterwards, so fseek to clear 208 _IOREAD flag. */ 209 if (fseek (asm_out_file, 0, SEEK_END) != 0) 210 fatal_error ("can%'t seek in %s: %m", asm_file_name); 211 212 gt_pch_save (pch_outfile); 213 cpp_write_pch_state (parse_in, pch_outfile); 214 215 if (fseek (pch_outfile, 0, SEEK_SET) != 0 216 || fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1) 217 fatal_error ("can%'t write %s: %m", pch_file); 218 219 fclose (pch_outfile); 220} 221 222/* Check the PCH file called NAME, open on FD, to see if it can be 223 used in this compilation. Return 1 if valid, 0 if the file can't 224 be used now but might be if it's seen later in the compilation, and 225 2 if this file could never be used in the compilation. */ 226 227int 228c_common_valid_pch (cpp_reader *pfile, const char *name, int fd) 229{ 230 int sizeread; 231 int result; 232 char ident[IDENT_LENGTH + 16]; 233 const char *pch_ident; 234 struct c_pch_validity v; 235 236 /* Perform a quick test of whether this is a valid 237 precompiled header for the current language. */ 238 239 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0); 240 241 sizeread = read (fd, ident, IDENT_LENGTH + 16); 242 if (sizeread == -1) 243 fatal_error ("can%'t read %s: %m", name); 244 else if (sizeread != IDENT_LENGTH + 16) 245 { 246 cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file", 247 name); 248 return 2; 249 } 250 251 pch_ident = get_ident(); 252 if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0) 253 { 254 if (cpp_get_options (pfile)->warn_invalid_pch) 255 { 256 if (memcmp (ident, pch_ident, 5) == 0) 257 /* It's a PCH, for the right language, but has the wrong version. 258 */ 259 cpp_error (pfile, CPP_DL_WARNING, 260 "%s: not compatible with this GCC version", name); 261 else if (memcmp (ident, pch_ident, 4) == 0) 262 /* It's a PCH for the wrong language. */ 263 cpp_error (pfile, CPP_DL_WARNING, "%s: not for %s", name, 264 lang_hooks.name); 265 else 266 /* Not any kind of PCH. */ 267 cpp_error (pfile, CPP_DL_WARNING, "%s: not a PCH file", name); 268 } 269 return 2; 270 } 271 if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0) 272 { 273 if (cpp_get_options (pfile)->warn_invalid_pch) 274 cpp_error (pfile, CPP_DL_WARNING, 275 "%s: created by a different GCC executable", name); 276 return 2; 277 } 278 279 /* At this point, we know it's a PCH file created by this 280 executable, so it ought to be long enough that we can read a 281 c_pch_validity structure. */ 282 if (read (fd, &v, sizeof (v)) != sizeof (v)) 283 fatal_error ("can%'t read %s: %m", name); 284 285 /* The allowable debug info combinations are that either the PCH file 286 was built with the same as is being used now, or the PCH file was 287 built for some kind of debug info but now none is in use. */ 288 if (v.debug_info_type != write_symbols 289 && write_symbols != NO_DEBUG) 290 { 291 if (cpp_get_options (pfile)->warn_invalid_pch) 292 cpp_error (pfile, CPP_DL_WARNING, 293 "%s: created with -g%s, but used with -g%s", name, 294 debug_type_names[v.debug_info_type], 295 debug_type_names[write_symbols]); 296 return 2; 297 } 298 299 /* Check flags that must match exactly. */ 300 { 301 size_t i; 302 for (i = 0; i < MATCH_SIZE; i++) 303 if (*pch_matching[i].flag_var != v.match[i]) 304 { 305 if (cpp_get_options (pfile)->warn_invalid_pch) 306 cpp_error (pfile, CPP_DL_WARNING, 307 "%s: settings for %s do not match", name, 308 pch_matching[i].flag_name); 309 return 2; 310 } 311 } 312 313 /* If the text segment was not loaded at the same address as it was 314 when the PCH file was created, function pointers loaded from the 315 PCH will not be valid. We could in theory remap all the function 316 pointers, but no support for that exists at present. 317 Since we have the same executable, it should only be necessary to 318 check one function. */ 319 if (v.pch_init != &pch_init) 320 { 321 if (cpp_get_options (pfile)->warn_invalid_pch) 322 cpp_error (pfile, CPP_DL_WARNING, 323 "%s: had text segment at different address", name); 324 return 2; 325 } 326 327 /* Check the target-specific validity data. */ 328 { 329 void *this_file_data = xmalloc (v.target_data_length); 330 const char *msg; 331 332 if ((size_t) read (fd, this_file_data, v.target_data_length) 333 != v.target_data_length) 334 fatal_error ("can%'t read %s: %m", name); 335 msg = targetm.pch_valid_p (this_file_data, v.target_data_length); 336 free (this_file_data); 337 if (msg != NULL) 338 { 339 if (cpp_get_options (pfile)->warn_invalid_pch) 340 cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg); 341 return 2; 342 } 343 } 344 345 /* Check the preprocessor macros are the same as when the PCH was 346 generated. */ 347 348 result = cpp_valid_state (pfile, name, fd); 349 if (result == -1) 350 return 2; 351 else 352 return result == 0; 353} 354 355/* If non-NULL, this function is called after a precompile header file 356 is loaded. */ 357void (*lang_post_pch_load) (void); 358 359/* Load in the PCH file NAME, open on FD. It was originally searched for 360 by ORIG_NAME. */ 361 362void 363c_common_read_pch (cpp_reader *pfile, const char *name, 364 int fd, const char *orig_name ATTRIBUTE_UNUSED) 365{ 366 FILE *f; 367 struct c_pch_header h; 368 struct save_macro_data *smd; 369 370 f = fdopen (fd, "rb"); 371 if (f == NULL) 372 { 373 cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen"); 374 return; 375 } 376 377 cpp_get_callbacks (parse_in)->valid_pch = NULL; 378 379 if (fread (&h, sizeof (h), 1, f) != 1) 380 { 381 cpp_errno (pfile, CPP_DL_ERROR, "reading"); 382 return; 383 } 384 385 if (!flag_preprocess_only) 386 { 387 unsigned long written; 388 char * buf = XNEWVEC (char, 16384); 389 390 for (written = 0; written < h.asm_size; ) 391 { 392 long size = h.asm_size - written; 393 if (size > 16384) 394 size = 16384; 395 if (fread (buf, size, 1, f) != 1 396 || fwrite (buf, size, 1, asm_out_file) != 1) 397 cpp_errno (pfile, CPP_DL_ERROR, "reading"); 398 written += size; 399 } 400 free (buf); 401 } 402 else 403 { 404 /* If we're preprocessing, don't write to a NULL 405 asm_out_file. */ 406 if (fseek (f, h.asm_size, SEEK_CUR) != 0) 407 cpp_errno (pfile, CPP_DL_ERROR, "seeking"); 408 } 409 410 cpp_prepare_state (pfile, &smd); 411 412 gt_pch_restore (f); 413 414 if (cpp_read_state (pfile, name, f, smd) != 0) 415 return; 416 417 fclose (f); 418 419 /* Give the front end a chance to take action after a PCH file has 420 been loaded. */ 421 if (lang_post_pch_load) 422 (*lang_post_pch_load) (); 423} 424 425/* Indicate that no more PCH files should be read. */ 426 427void 428c_common_no_more_pch (void) 429{ 430 if (cpp_get_callbacks (parse_in)->valid_pch) 431 { 432 cpp_get_callbacks (parse_in)->valid_pch = NULL; 433 host_hooks.gt_pch_use_address (NULL, 0, -1, 0); 434 } 435} 436 437/* Handle #pragma GCC pch_preprocess, to load in the PCH file. */ 438 439#ifndef O_BINARY 440# define O_BINARY 0 441#endif 442 443void 444c_common_pch_pragma (cpp_reader *pfile, const char *name) 445{ 446 int fd; 447 448 if (!cpp_get_options (pfile)->preprocessed) 449 { 450 error ("pch_preprocess pragma should only be used with -fpreprocessed"); 451 inform ("use #include instead"); 452 return; 453 } 454 455 fd = open (name, O_RDONLY | O_BINARY, 0666); 456 if (fd == -1) 457 fatal_error ("%s: couldn%'t open PCH file: %m", name); 458 459 if (c_common_valid_pch (pfile, name, fd) != 1) 460 { 461 if (!cpp_get_options (pfile)->warn_invalid_pch) 462 inform ("use -Winvalid-pch for more information"); 463 fatal_error ("%s: PCH file was invalid", name); 464 } 465 466 c_common_read_pch (pfile, name, fd, name); 467 468 close (fd); 469} 470 471/* Print out executable_checksum[]. */ 472 473void 474c_common_print_pch_checksum (FILE *f) 475{ 476 int i; 477 fputs ("Compiler executable checksum: ", f); 478 for (i = 0; i < 16; i++) 479 fprintf (f, "%02x", executable_checksum[i]); 480 putc ('\n', f); 481} 482