Mark ChangeLog
[official-gcc.git] / gcc / c-pch.c
blob76e40fb0a2686c96841931ff95914894112f0f1a
1 /* Precompiled header implementation for the C languages.
2 Copyright (C) 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
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"
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'. */
42 static const struct c_pch_matching
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" }
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 template[IDENT_LENGTH] = "gpch.013";
97 static const char c_language_chars[] = "Co+O";
99 memcpy (result, template, 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[IDENT_LENGTH] = "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 cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file",
247 name);
248 return 2;
251 pch_ident = get_ident();
252 if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
254 if (cpp_get_options (pfile)->warn_invalid_pch)
256 if (memcmp (ident, pch_ident, 5) == 0)
257 /* It's a PCH, for the right language, but has the wrong version.
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);
269 return 2;
271 if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
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;
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);
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)
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;
299 /* Check flags that must match exactly. */
301 size_t i;
302 for (i = 0; i < MATCH_SIZE; i++)
303 if (*pch_matching[i].flag_var != v.match[i])
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;
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)
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;
327 /* Check the target-specific validity data. */
329 void *this_file_data = xmalloc (v.target_data_length);
330 const char *msg;
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)
339 if (cpp_get_options (pfile)->warn_invalid_pch)
340 cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
341 return 2;
345 /* Check the preprocessor macros are the same as when the PCH was
346 generated. */
348 result = cpp_valid_state (pfile, name, fd);
349 if (result == -1)
350 return 2;
351 else
352 return result == 0;
355 /* If non-NULL, this function is called after a precompile header file
356 is loaded. */
357 void (*lang_post_pch_load) (void);
359 /* Load in the PCH file NAME, open on FD. It was originally searched for
360 by ORIG_NAME. */
362 void
363 c_common_read_pch (cpp_reader *pfile, const char *name,
364 int fd, const char *orig_name ATTRIBUTE_UNUSED)
366 FILE *f;
367 struct c_pch_header h;
368 struct save_macro_data *smd;
370 f = fdopen (fd, "rb");
371 if (f == NULL)
373 cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
374 return;
377 cpp_get_callbacks (parse_in)->valid_pch = NULL;
379 if (fread (&h, sizeof (h), 1, f) != 1)
381 cpp_errno (pfile, CPP_DL_ERROR, "reading");
382 return;
385 if (!flag_preprocess_only)
387 unsigned long written;
388 char * buf = XNEWVEC (char, 16384);
390 for (written = 0; written < h.asm_size; )
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;
400 free (buf);
402 else
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");
410 cpp_prepare_state (pfile, &smd);
412 gt_pch_restore (f);
414 if (cpp_read_state (pfile, name, f, smd) != 0)
415 return;
417 fclose (f);
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) ();
425 /* Indicate that no more PCH files should be read. */
427 void
428 c_common_no_more_pch (void)
430 if (cpp_get_callbacks (parse_in)->valid_pch)
432 cpp_get_callbacks (parse_in)->valid_pch = NULL;
433 host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
437 /* Handle #pragma GCC pch_preprocess, to load in the PCH file. */
439 #ifndef O_BINARY
440 # define O_BINARY 0
441 #endif
443 void
444 c_common_pch_pragma (cpp_reader *pfile, const char *name)
446 int fd;
448 if (!cpp_get_options (pfile)->preprocessed)
450 error ("pch_preprocess pragma should only be used with -fpreprocessed");
451 inform ("use #include instead");
452 return;
455 fd = open (name, O_RDONLY | O_BINARY, 0666);
456 if (fd == -1)
457 fatal_error ("%s: couldn%'t open PCH file: %m", name);
459 if (c_common_valid_pch (pfile, name, fd) != 1)
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);
466 c_common_read_pch (pfile, name, fd, name);
468 close (fd);
471 /* Print out executable_checksum[]. */
473 void
474 c_common_print_pch_checksum (FILE *f)
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);