OSDN Git Service

* gcc.dg/vect/vect.exp: Run tests with -funroll-loops for SPU in case
[pf3gnuchains/gcc-fork.git] / gcc / c-pch.c
1 /* Precompiled header implementation for the C languages.
2    Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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 3, or (at your option)
9 any later version.
10
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.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "version.h"
24 #include "cpplib.h"
25 #include "tree.h"
26 #include "flags.h"
27 #include "c-common.h"
28 #include "output.h"
29 #include "toplev.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
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
42 static 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
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 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
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[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
172 void
173 c_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
227 int
228 c_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       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;
250     }
251
252   pch_ident = get_ident();
253   if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
254     {
255       if (cpp_get_options (pfile)->warn_invalid_pch)
256         {
257           if (memcmp (ident, pch_ident, 5) == 0)
258             /* It's a PCH, for the right language, but has the wrong version.
259              */
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);
269         }
270       return 2;
271     }
272   if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
273     {
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;
278     }
279
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);
285
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)
291     {
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;
298     }
299
300   /* Check flags that must match exactly.  */
301   {
302     size_t i;
303     for (i = 0; i < MATCH_SIZE; i++)
304       if (*pch_matching[i].flag_var != v.match[i])
305         {
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;
311         }
312   }
313
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)
321     {
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;
326     }
327
328   /* Check the target-specific validity data.  */
329   {
330     void *this_file_data = xmalloc (v.target_data_length);
331     const char *msg;
332
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)
339       {
340         if (cpp_get_options (pfile)->warn_invalid_pch)
341           cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
342         return 2;
343       }
344   }
345
346   /* Check the preprocessor macros are the same as when the PCH was
347      generated.  */
348
349   result = cpp_valid_state (pfile, name, fd);
350   if (result == -1)
351     return 2;
352   else
353     return result == 0;
354 }
355
356 /* If non-NULL, this function is called after a precompile header file
357    is loaded.  */
358 void (*lang_post_pch_load) (void);
359
360 /* Load in the PCH file NAME, open on FD.  It was originally searched for
361    by ORIG_NAME.  */
362
363 void
364 c_common_read_pch (cpp_reader *pfile, const char *name,
365                    int fd, const char *orig_name ATTRIBUTE_UNUSED)
366 {
367   FILE *f;
368   struct c_pch_header h;
369   struct save_macro_data *smd;
370   expanded_location saved_loc;
371
372   f = fdopen (fd, "rb");
373   if (f == NULL)
374     {
375       cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
376       close (fd);
377       return;
378     }
379
380   cpp_get_callbacks (parse_in)->valid_pch = NULL;
381
382   if (fread (&h, sizeof (h), 1, f) != 1)
383     {
384       cpp_errno (pfile, CPP_DL_ERROR, "reading");
385       fclose (f);
386       return;
387     }
388
389   if (!flag_preprocess_only)
390     {
391       unsigned long written;
392       char * buf = XNEWVEC (char, 16384);
393
394       for (written = 0; written < h.asm_size; )
395         {
396           long size = h.asm_size - written;
397           if (size > 16384)
398             size = 16384;
399           if (fread (buf, size, 1, f) != 1
400               || fwrite (buf, size, 1, asm_out_file) != 1)
401             cpp_errno (pfile, CPP_DL_ERROR, "reading");
402           written += size;
403         }
404       free (buf);
405     }
406   else
407     {
408       /* If we're preprocessing, don't write to a NULL
409          asm_out_file.  */
410       if (fseek (f, h.asm_size, SEEK_CUR) != 0)
411         cpp_errno (pfile, CPP_DL_ERROR, "seeking");
412     }
413
414   /* Save the location and then restore it after reading the PCH.  */
415   saved_loc = expand_location (line_table->highest_line);
416
417   cpp_prepare_state (pfile, &smd);
418
419   gt_pch_restore (f);
420
421   if (cpp_read_state (pfile, name, f, smd) != 0)
422     {
423       fclose (f);
424       return;
425     }
426
427   fclose (f);
428
429   cpp_set_line_map (pfile, line_table);
430   linemap_add (line_table, LC_RENAME, 0, saved_loc.file, saved_loc.line);
431
432   /* Give the front end a chance to take action after a PCH file has
433      been loaded.  */
434   if (lang_post_pch_load)
435     (*lang_post_pch_load) ();
436 }
437
438 /* Indicate that no more PCH files should be read.  */
439
440 void
441 c_common_no_more_pch (void)
442 {
443   if (cpp_get_callbacks (parse_in)->valid_pch)
444     {
445       cpp_get_callbacks (parse_in)->valid_pch = NULL;
446       host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
447     }
448 }
449
450 /* Handle #pragma GCC pch_preprocess, to load in the PCH file.  */
451
452 #ifndef O_BINARY
453 # define O_BINARY 0
454 #endif
455
456 void
457 c_common_pch_pragma (cpp_reader *pfile, const char *name)
458 {
459   int fd;
460
461   if (!cpp_get_options (pfile)->preprocessed)
462     {
463       error ("pch_preprocess pragma should only be used with -fpreprocessed");
464       inform ("use #include instead");
465       return;
466     }
467
468   fd = open (name, O_RDONLY | O_BINARY, 0666);
469   if (fd == -1)
470     fatal_error ("%s: couldn%'t open PCH file: %m", name);
471
472   if (c_common_valid_pch (pfile, name, fd) != 1)
473     {
474       if (!cpp_get_options (pfile)->warn_invalid_pch)
475         inform ("use -Winvalid-pch for more information");
476       fatal_error ("%s: PCH file was invalid", name);
477     }
478
479   c_common_read_pch (pfile, name, fd, name);
480
481   close (fd);
482 }
483
484 /* Print out executable_checksum[].  */
485
486 void
487 c_common_print_pch_checksum (FILE *f)
488 {
489   int i;
490   fputs ("Compiler executable checksum: ", f);
491   for (i = 0; i < 16; i++)
492     fprintf (f, "%02x", executable_checksum[i]);
493   putc ('\n', f);
494 }