re PR testsuite/40567 (Revision 149002 caused many failures)
[official-gcc.git] / gcc / c-pch.c
blobabdf4ab46772e00505911044b1097f666ded3946
1 /* Precompiled header implementation for the C languages.
2 Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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.
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.
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/>. */
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 #include "opts.h"
39 /* This is a list of flag variables that must match exactly, and their
40 names for the error message. The possible values for *flag_var must
41 fit in a 'signed char'. */
43 static const struct c_pch_matching
45 int *flag_var;
46 const char *flag_name;
47 } pch_matching[] = {
48 { &flag_exceptions, "-fexceptions" },
51 enum {
52 MATCH_SIZE = ARRAY_SIZE (pch_matching)
55 /* The value of the checksum in the dummy compiler that is actually
56 checksummed. That compiler should never be run. */
57 static const char no_checksum[16] = { 0 };
59 /* Information about flags and suchlike that affect PCH validity.
61 Before this structure is read, both an initial 8-character identification
62 string, and a 16-byte checksum, have been read and validated. */
64 struct c_pch_validity
66 unsigned char debug_info_type;
67 signed char match[MATCH_SIZE];
68 void (*pch_init) (void);
69 size_t target_data_length;
72 struct c_pch_header
74 unsigned long asm_size;
77 #define IDENT_LENGTH 8
79 /* The file we'll be writing the PCH to. */
80 static FILE *pch_outfile;
82 /* The position in the assembler output file when pch_init was called. */
83 static long asm_file_startpos;
85 static const char *get_ident (void);
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. */
92 static const char *
93 get_ident (void)
95 static char result[IDENT_LENGTH];
96 static const char templ[] = "gpch.013";
97 static const char c_language_chars[] = "Co+O";
99 memcpy (result, templ, IDENT_LENGTH);
100 result[4] = c_language_chars[c_language];
102 return result;
105 /* Prepare to write a PCH file, if one is being written. This is
106 called at the start of compilation.
108 Also, print out the executable checksum if -fverbose-asm is in effect. */
110 void
111 pch_init (void)
113 FILE *f;
114 struct c_pch_validity v;
115 void *target_validity;
116 static const char partial_pch[] = "gpcWrite";
118 #ifdef ASM_COMMENT_START
119 if (flag_verbose_asm)
121 fprintf (asm_out_file, "%s ", ASM_COMMENT_START);
122 c_common_print_pch_checksum (asm_out_file);
123 fputc ('\n', asm_out_file);
125 #endif
127 if (!pch_file)
128 return;
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;
135 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
137 v.debug_info_type = write_symbols;
139 size_t i;
140 for (i = 0; i < MATCH_SIZE; i++)
142 v.match[i] = *pch_matching[i].flag_var;
143 gcc_assert (v.match[i] == *pch_matching[i].flag_var);
146 v.pch_init = &pch_init;
147 target_validity = targetm.get_pch_validity (&v.target_data_length);
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);
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);
161 asm_file_startpos = ftell (asm_out_file);
163 /* Let the debugging format deal with the PCHness. */
164 (*debug_hooks->handle_pch) (0);
166 cpp_save_state (parse_in, f);
169 /* Write the PCH file. This is called at the end of a compilation which
170 will produce a PCH file. */
172 void
173 c_common_write_pch (void)
175 char *buf;
176 long asm_file_end;
177 long written;
178 struct c_pch_header h;
180 (*debug_hooks->handle_pch) (1);
182 cpp_write_pch_deps (parse_in, pch_outfile);
184 asm_file_end = ftell (asm_out_file);
185 h.asm_size = asm_file_end - asm_file_startpos;
187 if (fwrite (&h, sizeof (h), 1, pch_outfile) != 1)
188 fatal_error ("can%'t write %s: %m", pch_file);
190 buf = XNEWVEC (char, 16384);
192 if (fseek (asm_out_file, asm_file_startpos, SEEK_SET) != 0)
193 fatal_error ("can%'t seek in %s: %m", asm_file_name);
195 for (written = asm_file_startpos; written < asm_file_end; )
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;
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);
212 gt_pch_save (pch_outfile);
213 cpp_write_pch_state (parse_in, pch_outfile);
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);
219 fclose (pch_outfile);
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. */
228 c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)
230 int sizeread;
231 int result;
232 char ident[IDENT_LENGTH + 16];
233 const char *pch_ident;
234 struct c_pch_validity v;
236 /* Perform a quick test of whether this is a valid
237 precompiled header for the current language. */
239 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
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)
246 if (cpp_get_options (pfile)->warn_invalid_pch)
247 cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file",
248 name);
249 return 2;
252 pch_ident = get_ident();
253 if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
255 if (cpp_get_options (pfile)->warn_invalid_pch)
257 if (memcmp (ident, pch_ident, 5) == 0)
258 /* It's a PCH, for the right language, but has the wrong version.
260 cpp_error (pfile, CPP_DL_WARNING,
261 "%s: not compatible with this GCC version", name);
262 else if (memcmp (ident, pch_ident, 4) == 0)
263 /* It's a PCH for the wrong language. */
264 cpp_error (pfile, CPP_DL_WARNING, "%s: not for %s", name,
265 lang_hooks.name);
266 else
267 /* Not any kind of PCH. */
268 cpp_error (pfile, CPP_DL_WARNING, "%s: not a PCH file", name);
270 return 2;
272 if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
274 if (cpp_get_options (pfile)->warn_invalid_pch)
275 cpp_error (pfile, CPP_DL_WARNING,
276 "%s: created by a different GCC executable", name);
277 return 2;
280 /* At this point, we know it's a PCH file created by this
281 executable, so it ought to be long enough that we can read a
282 c_pch_validity structure. */
283 if (read (fd, &v, sizeof (v)) != sizeof (v))
284 fatal_error ("can%'t read %s: %m", name);
286 /* The allowable debug info combinations are that either the PCH file
287 was built with the same as is being used now, or the PCH file was
288 built for some kind of debug info but now none is in use. */
289 if (v.debug_info_type != write_symbols
290 && write_symbols != NO_DEBUG)
292 if (cpp_get_options (pfile)->warn_invalid_pch)
293 cpp_error (pfile, CPP_DL_WARNING,
294 "%s: created with -g%s, but used with -g%s", name,
295 debug_type_names[v.debug_info_type],
296 debug_type_names[write_symbols]);
297 return 2;
300 /* Check flags that must match exactly. */
302 size_t i;
303 for (i = 0; i < MATCH_SIZE; i++)
304 if (*pch_matching[i].flag_var != v.match[i])
306 if (cpp_get_options (pfile)->warn_invalid_pch)
307 cpp_error (pfile, CPP_DL_WARNING,
308 "%s: settings for %s do not match", name,
309 pch_matching[i].flag_name);
310 return 2;
314 /* If the text segment was not loaded at the same address as it was
315 when the PCH file was created, function pointers loaded from the
316 PCH will not be valid. We could in theory remap all the function
317 pointers, but no support for that exists at present.
318 Since we have the same executable, it should only be necessary to
319 check one function. */
320 if (v.pch_init != &pch_init)
322 if (cpp_get_options (pfile)->warn_invalid_pch)
323 cpp_error (pfile, CPP_DL_WARNING,
324 "%s: had text segment at different address", name);
325 return 2;
328 /* Check the target-specific validity data. */
330 void *this_file_data = xmalloc (v.target_data_length);
331 const char *msg;
333 if ((size_t) read (fd, this_file_data, v.target_data_length)
334 != v.target_data_length)
335 fatal_error ("can%'t read %s: %m", name);
336 msg = targetm.pch_valid_p (this_file_data, v.target_data_length);
337 free (this_file_data);
338 if (msg != NULL)
340 if (cpp_get_options (pfile)->warn_invalid_pch)
341 cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
342 return 2;
346 /* Check the preprocessor macros are the same as when the PCH was
347 generated. */
349 result = cpp_valid_state (pfile, name, fd);
350 if (result == -1)
351 return 2;
352 else
353 return result == 0;
356 /* If non-NULL, this function is called after a precompile header file
357 is loaded. */
358 void (*lang_post_pch_load) (void);
360 /* Load in the PCH file NAME, open on FD. It was originally searched for
361 by ORIG_NAME. */
363 void
364 c_common_read_pch (cpp_reader *pfile, const char *name,
365 int fd, const char *orig_name ATTRIBUTE_UNUSED)
367 FILE *f;
368 struct c_pch_header h;
369 struct save_macro_data *smd;
370 expanded_location saved_loc;
371 bool saved_trace_includes;
373 f = fdopen (fd, "rb");
374 if (f == NULL)
376 cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
377 close (fd);
378 return;
381 cpp_get_callbacks (parse_in)->valid_pch = NULL;
383 if (fread (&h, sizeof (h), 1, f) != 1)
385 cpp_errno (pfile, CPP_DL_ERROR, "reading");
386 fclose (f);
387 return;
390 if (!flag_preprocess_only)
392 unsigned long written;
393 char * buf = XNEWVEC (char, 16384);
395 for (written = 0; written < h.asm_size; )
397 long size = h.asm_size - written;
398 if (size > 16384)
399 size = 16384;
400 if (fread (buf, size, 1, f) != 1
401 || fwrite (buf, size, 1, asm_out_file) != 1)
402 cpp_errno (pfile, CPP_DL_ERROR, "reading");
403 written += size;
405 free (buf);
407 else
409 /* If we're preprocessing, don't write to a NULL
410 asm_out_file. */
411 if (fseek (f, h.asm_size, SEEK_CUR) != 0)
412 cpp_errno (pfile, CPP_DL_ERROR, "seeking");
415 /* Save the location and then restore it after reading the PCH. */
416 saved_loc = expand_location (line_table->highest_line);
417 saved_trace_includes = line_table->trace_includes;
419 cpp_prepare_state (pfile, &smd);
421 gt_pch_restore (f);
423 if (cpp_read_state (pfile, name, f, smd) != 0)
425 fclose (f);
426 return;
429 fclose (f);
431 line_table->trace_includes = saved_trace_includes;
432 cpp_set_line_map (pfile, line_table);
433 linemap_add (line_table, LC_RENAME, 0, saved_loc.file, saved_loc.line);
435 /* Give the front end a chance to take action after a PCH file has
436 been loaded. */
437 if (lang_post_pch_load)
438 (*lang_post_pch_load) ();
441 /* Indicate that no more PCH files should be read. */
443 void
444 c_common_no_more_pch (void)
446 if (cpp_get_callbacks (parse_in)->valid_pch)
448 cpp_get_callbacks (parse_in)->valid_pch = NULL;
449 host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
453 /* Handle #pragma GCC pch_preprocess, to load in the PCH file. */
455 #ifndef O_BINARY
456 # define O_BINARY 0
457 #endif
459 void
460 c_common_pch_pragma (cpp_reader *pfile, const char *name)
462 int fd;
464 if (!cpp_get_options (pfile)->preprocessed)
466 error ("pch_preprocess pragma should only be used with -fpreprocessed");
467 inform (input_location, "use #include instead");
468 return;
471 fd = open (name, O_RDONLY | O_BINARY, 0666);
472 if (fd == -1)
473 fatal_error ("%s: couldn%'t open PCH file: %m", name);
475 if (c_common_valid_pch (pfile, name, fd) != 1)
477 if (!cpp_get_options (pfile)->warn_invalid_pch)
478 inform (input_location, "use -Winvalid-pch for more information");
479 fatal_error ("%s: PCH file was invalid", name);
482 c_common_read_pch (pfile, name, fd, name);
484 close (fd);
487 /* Print out executable_checksum[]. */
489 void
490 c_common_print_pch_checksum (FILE *f)
492 int i;
493 fputs ("Compiler executable checksum: ", f);
494 for (i = 0; i < 16; i++)
495 fprintf (f, "%02x", executable_checksum[i]);
496 putc ('\n', f);