OSDN Git Service

3c2fd18f06337639c3fb86283cecc4757946c8e3
[pf3gnuchains/gcc-fork.git] / gcc / c-family / c-pch.c
1 /* Precompiled header implementation for the C languages.
2    Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3    Free Software Foundation, Inc.
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 #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 "debug.h"
31 #include "c-pragma.h"
32 #include "ggc.h"
33 #include "langhooks.h"
34 #include "hosthooks.h"
35 #include "target.h"
36 #include "opts.h"
37 #include "timevar.h"
38
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'.  */
42
43 static const struct c_pch_matching
44 {
45   int *flag_var;
46   const char *flag_name;
47 } pch_matching[] = {
48   { &flag_exceptions, "-fexceptions" },
49 };
50
51 enum {
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.  */
57 static 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
64 struct 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
72 struct 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.  */
80 static FILE *pch_outfile;
81
82 /* The position in the assembler output file when pch_init was called.  */
83 static long asm_file_startpos;
84
85 static 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
92 static const char *
93 get_ident (void)
94 {
95   static char result[IDENT_LENGTH];
96   static const char templ[] = "gpch.013";
97   static const char c_language_chars[] = "Co+O";
98
99   memcpy (result, templ, 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
110 void
111 pch_init (void)
112 {
113   FILE *f;
114   struct c_pch_validity v;
115   void *target_validity;
116   static const char partial_pch[] = "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   memset (&v, '\0', sizeof (v));
138   v.debug_info_type = write_symbols;
139   {
140     size_t i;
141     for (i = 0; i < MATCH_SIZE; i++)
142       {
143         v.match[i] = *pch_matching[i].flag_var;
144         gcc_assert (v.match[i] == *pch_matching[i].flag_var);
145       }
146   }
147   v.pch_init = &pch_init;
148   target_validity = targetm.get_pch_validity (&v.target_data_length);
149
150   if (fwrite (partial_pch, IDENT_LENGTH, 1, f) != 1
151       || fwrite (executable_checksum, 16, 1, f) != 1
152       || fwrite (&v, sizeof (v), 1, f) != 1
153       || fwrite (target_validity, v.target_data_length, 1, f) != 1)
154     fatal_error ("can%'t write to %s: %m", pch_file);
155
156   /* We need to be able to re-read the output.  */
157   /* The driver always provides a valid -o option.  */
158   if (asm_file_name == NULL
159       || strcmp (asm_file_name, "-") == 0)
160     fatal_error ("%qs is not a valid output file", asm_file_name);
161
162   asm_file_startpos = ftell (asm_out_file);
163
164   /* Let the debugging format deal with the PCHness.  */
165   (*debug_hooks->handle_pch) (0);
166
167   cpp_save_state (parse_in, f);
168 }
169
170 /* Write the PCH file.  This is called at the end of a compilation which
171    will produce a PCH file.  */
172
173 void
174 c_common_write_pch (void)
175 {
176   char *buf;
177   long asm_file_end;
178   long written;
179   struct c_pch_header h;
180
181   timevar_push (TV_PCH_SAVE);
182
183   (*debug_hooks->handle_pch) (1);
184
185   cpp_write_pch_deps (parse_in, pch_outfile);
186
187   asm_file_end = ftell (asm_out_file);
188   h.asm_size = asm_file_end - asm_file_startpos;
189
190   if (fwrite (&h, sizeof (h), 1, pch_outfile) != 1)
191     fatal_error ("can%'t write %s: %m", pch_file);
192
193   buf = XNEWVEC (char, 16384);
194
195   if (fseek (asm_out_file, asm_file_startpos, SEEK_SET) != 0)
196     fatal_error ("can%'t seek in %s: %m", asm_file_name);
197
198   for (written = asm_file_startpos; written < asm_file_end; )
199     {
200       long size = asm_file_end - written;
201       if (size > 16384)
202         size = 16384;
203       if (fread (buf, size, 1, asm_out_file) != 1)
204         fatal_error ("can%'t read %s: %m", asm_file_name);
205       if (fwrite (buf, size, 1, pch_outfile) != 1)
206         fatal_error ("can%'t write %s: %m", pch_file);
207       written += size;
208     }
209   free (buf);
210   /* asm_out_file can be written afterwards, so fseek to clear
211      _IOREAD flag.  */
212   if (fseek (asm_out_file, 0, SEEK_END) != 0)
213     fatal_error ("can%'t seek in %s: %m", asm_file_name);
214
215   gt_pch_save (pch_outfile);
216
217   timevar_push (TV_PCH_CPP_SAVE);
218   cpp_write_pch_state (parse_in, pch_outfile);
219   timevar_pop (TV_PCH_CPP_SAVE);
220
221   if (fseek (pch_outfile, 0, SEEK_SET) != 0
222       || fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1)
223     fatal_error ("can%'t write %s: %m", pch_file);
224
225   fclose (pch_outfile);
226
227   timevar_pop (TV_PCH_SAVE);
228 }
229
230 /* Check the PCH file called NAME, open on FD, to see if it can be
231    used in this compilation.  Return 1 if valid, 0 if the file can't
232    be used now but might be if it's seen later in the compilation, and
233    2 if this file could never be used in the compilation.  */
234
235 int
236 c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)
237 {
238   int sizeread;
239   int result;
240   char ident[IDENT_LENGTH + 16];
241   const char *pch_ident;
242   struct c_pch_validity v;
243
244   /* Perform a quick test of whether this is a valid
245      precompiled header for the current language.  */
246
247   gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
248
249   sizeread = read (fd, ident, IDENT_LENGTH + 16);
250   if (sizeread == -1)
251     fatal_error ("can%'t read %s: %m", name);
252   else if (sizeread != IDENT_LENGTH + 16)
253     {
254       if (cpp_get_options (pfile)->warn_invalid_pch)
255         cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file",
256                    name);
257       return 2;
258     }
259
260   pch_ident = get_ident();
261   if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
262     {
263       if (cpp_get_options (pfile)->warn_invalid_pch)
264         {
265           if (memcmp (ident, pch_ident, 5) == 0)
266             /* It's a PCH, for the right language, but has the wrong version.
267              */
268             cpp_error (pfile, CPP_DL_WARNING,
269                        "%s: not compatible with this GCC version", name);
270           else if (memcmp (ident, pch_ident, 4) == 0)
271             /* It's a PCH for the wrong language.  */
272             cpp_error (pfile, CPP_DL_WARNING, "%s: not for %s", name,
273                        lang_hooks.name);
274           else
275             /* Not any kind of PCH.  */
276             cpp_error (pfile, CPP_DL_WARNING, "%s: not a PCH file", name);
277         }
278       return 2;
279     }
280   if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
281     {
282       if (cpp_get_options (pfile)->warn_invalid_pch)
283         cpp_error (pfile, CPP_DL_WARNING,
284                    "%s: created by a different GCC executable", name);
285       return 2;
286     }
287
288   /* At this point, we know it's a PCH file created by this
289      executable, so it ought to be long enough that we can read a
290      c_pch_validity structure.  */
291   if (read (fd, &v, sizeof (v)) != sizeof (v))
292     fatal_error ("can%'t read %s: %m", name);
293
294   /* The allowable debug info combinations are that either the PCH file
295      was built with the same as is being used now, or the PCH file was
296      built for some kind of debug info but now none is in use.  */
297   if (v.debug_info_type != write_symbols
298       && write_symbols != NO_DEBUG)
299     {
300       if (cpp_get_options (pfile)->warn_invalid_pch)
301         cpp_error (pfile, CPP_DL_WARNING,
302                    "%s: created with -g%s, but used with -g%s", name,
303                    debug_type_names[v.debug_info_type],
304                    debug_type_names[write_symbols]);
305       return 2;
306     }
307
308   /* Check flags that must match exactly.  */
309   {
310     size_t i;
311     for (i = 0; i < MATCH_SIZE; i++)
312       if (*pch_matching[i].flag_var != v.match[i])
313         {
314           if (cpp_get_options (pfile)->warn_invalid_pch)
315             cpp_error (pfile, CPP_DL_WARNING,
316                        "%s: settings for %s do not match", name,
317                        pch_matching[i].flag_name);
318           return 2;
319         }
320   }
321
322   /* If the text segment was not loaded at the same address as it was
323      when the PCH file was created, function pointers loaded from the
324      PCH will not be valid.  We could in theory remap all the function
325      pointers, but no support for that exists at present.
326      Since we have the same executable, it should only be necessary to
327      check one function.  */
328   if (v.pch_init != &pch_init)
329     {
330       if (cpp_get_options (pfile)->warn_invalid_pch)
331         cpp_error (pfile, CPP_DL_WARNING,
332                    "%s: had text segment at different address", name);
333       return 2;
334     }
335
336   /* Check the target-specific validity data.  */
337   {
338     void *this_file_data = xmalloc (v.target_data_length);
339     const char *msg;
340
341     if ((size_t) read (fd, this_file_data, v.target_data_length)
342         != v.target_data_length)
343       fatal_error ("can%'t read %s: %m", name);
344     msg = targetm.pch_valid_p (this_file_data, v.target_data_length);
345     free (this_file_data);
346     if (msg != NULL)
347       {
348         if (cpp_get_options (pfile)->warn_invalid_pch)
349           cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
350         return 2;
351       }
352   }
353
354   /* Check the preprocessor macros are the same as when the PCH was
355      generated.  */
356
357   result = cpp_valid_state (pfile, name, fd);
358   if (result == -1)
359     return 2;
360   else
361     return result == 0;
362 }
363
364 /* If non-NULL, this function is called after a precompile header file
365    is loaded.  */
366 void (*lang_post_pch_load) (void);
367
368 /* Load in the PCH file NAME, open on FD.  It was originally searched for
369    by ORIG_NAME.  */
370
371 void
372 c_common_read_pch (cpp_reader *pfile, const char *name,
373                    int fd, const char *orig_name ATTRIBUTE_UNUSED)
374 {
375   FILE *f;
376   struct c_pch_header h;
377   struct save_macro_data *smd;
378   expanded_location saved_loc;
379   bool saved_trace_includes;
380
381   timevar_push (TV_PCH_RESTORE);
382
383   f = fdopen (fd, "rb");
384   if (f == NULL)
385     {
386       cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
387       close (fd);
388       goto end;
389     }
390
391   cpp_get_callbacks (parse_in)->valid_pch = NULL;
392
393   if (fread (&h, sizeof (h), 1, f) != 1)
394     {
395       cpp_errno (pfile, CPP_DL_ERROR, "reading");
396       fclose (f);
397       goto end;
398     }
399
400   if (!flag_preprocess_only)
401     {
402       unsigned long written;
403       char * buf = XNEWVEC (char, 16384);
404
405       for (written = 0; written < h.asm_size; )
406         {
407           long size = h.asm_size - written;
408           if (size > 16384)
409             size = 16384;
410           if (fread (buf, size, 1, f) != 1
411               || fwrite (buf, size, 1, asm_out_file) != 1)
412             cpp_errno (pfile, CPP_DL_ERROR, "reading");
413           written += size;
414         }
415       free (buf);
416     }
417   else
418     {
419       /* If we're preprocessing, don't write to a NULL
420          asm_out_file.  */
421       if (fseek (f, h.asm_size, SEEK_CUR) != 0)
422         cpp_errno (pfile, CPP_DL_ERROR, "seeking");
423     }
424
425   /* Save the location and then restore it after reading the PCH.  */
426   saved_loc = expand_location (line_table->highest_line);
427   saved_trace_includes = line_table->trace_includes;
428
429   timevar_push (TV_PCH_CPP_RESTORE);
430   cpp_prepare_state (pfile, &smd);
431   timevar_pop (TV_PCH_CPP_RESTORE);
432
433   gt_pch_restore (f);
434   cpp_set_line_map (pfile, line_table);
435
436   timevar_push (TV_PCH_CPP_RESTORE);
437   if (cpp_read_state (pfile, name, f, smd) != 0)
438     {
439       fclose (f);
440       timevar_pop (TV_PCH_CPP_RESTORE);
441       goto end;
442     }
443   timevar_pop (TV_PCH_CPP_RESTORE);
444
445
446   fclose (f);
447
448   line_table->trace_includes = saved_trace_includes;
449   linemap_add (line_table, LC_RENAME, 0, saved_loc.file, saved_loc.line);
450
451   /* Give the front end a chance to take action after a PCH file has
452      been loaded.  */
453   if (lang_post_pch_load)
454     (*lang_post_pch_load) ();
455
456 end:
457   timevar_pop (TV_PCH_RESTORE);
458 }
459
460 /* Indicate that no more PCH files should be read.  */
461
462 void
463 c_common_no_more_pch (void)
464 {
465   if (cpp_get_callbacks (parse_in)->valid_pch)
466     {
467       cpp_get_callbacks (parse_in)->valid_pch = NULL;
468       host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
469     }
470 }
471
472 /* Handle #pragma GCC pch_preprocess, to load in the PCH file.  */
473
474 void
475 c_common_pch_pragma (cpp_reader *pfile, const char *name)
476 {
477   int fd;
478
479   if (!cpp_get_options (pfile)->preprocessed)
480     {
481       error ("pch_preprocess pragma should only be used with -fpreprocessed");
482       inform (input_location, "use #include instead");
483       return;
484     }
485
486   fd = open (name, O_RDONLY | O_BINARY, 0666);
487   if (fd == -1)
488     fatal_error ("%s: couldn%'t open PCH file: %m", name);
489
490   if (c_common_valid_pch (pfile, name, fd) != 1)
491     {
492       if (!cpp_get_options (pfile)->warn_invalid_pch)
493         inform (input_location, "use -Winvalid-pch for more information");
494       fatal_error ("%s: PCH file was invalid", name);
495     }
496
497   c_common_read_pch (pfile, name, fd, name);
498
499   close (fd);
500 }
501
502 /* Print out executable_checksum[].  */
503
504 void
505 c_common_print_pch_checksum (FILE *f)
506 {
507   int i;
508   fputs ("Compiler executable checksum: ", f);
509   for (i = 0; i < 16; i++)
510     fprintf (f, "%02x", executable_checksum[i]);
511   putc ('\n', f);
512 }