1/* Precompiled header implementation for the C languages. 2 Copyright (C) 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GCC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING. If not, write to 18the Free Software Foundation, 51 Franklin Street, Fifth Floor, 19Boston, MA 02110-1301, USA. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "version.h" 25#include "cpplib.h" 26#include "tree.h" 27#include "flags.h" 28#include "c-common.h" 29#include "output.h" 30#include "toplev.h" 31#include "debug.h" 32#include "c-pragma.h" 33#include "ggc.h" 34#include "langhooks.h" 35#include "hosthooks.h" 36#include "target.h" 37 38/* This is a list of flag variables that must match exactly, and their 39 names for the error message. The possible values for *flag_var must 40 fit in a 'signed char'. */ 41 42static const struct c_pch_matching 43{ 44 int *flag_var; 45 const char *flag_name; 46} pch_matching[] = { 47 { &flag_exceptions, "-fexceptions" }, 48 { &flag_unit_at_a_time, "-funit-at-a-time" } 49}; 50 51enum { 52 MATCH_SIZE = ARRAY_SIZE (pch_matching) 53}; 54 55/* The value of the checksum in the dummy compiler that is actually 56 checksummed. That compiler should never be run. */ 57static const char no_checksum[16] = { 0 }; 58 59/* Information about flags and suchlike that affect PCH validity. 60 61 Before this structure is read, both an initial 8-character identification 62 string, and a 16-byte checksum, have been read and validated. */ 63 64struct c_pch_validity 65{ 66 unsigned char debug_info_type; 67 signed char match[MATCH_SIZE]; 68 void (*pch_init) (void); 69 size_t target_data_length; 70}; 71 72struct c_pch_header 73{ 74 unsigned long asm_size; 75}; 76 77#define IDENT_LENGTH 8 78 79/* The file we'll be writing the PCH to. */ 80static FILE *pch_outfile; 81 82/* The position in the assembler output file when pch_init was called. */ 83static long asm_file_startpos; 84 85static const char *get_ident (void); 86 87/* Compute an appropriate 8-byte magic number for the PCH file, so that 88 utilities like file(1) can identify it, and so that GCC can quickly 89 ignore non-PCH files and PCH files that are of a completely different 90 format. */ 91 92static const char * 93get_ident (void) 94{ 95 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