1/* Precompiled header implementation for the C languages.
2 Copyright (C) 2000-2017 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 3, 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 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 "target.h"
24#include "c-common.h"
25#include "timevar.h"
26#include "flags.h"
27#include "debug.h"
28#include "c-pragma.h"
29#include "langhooks.h"
30#include "hosthooks.h"
31
32/* This is a list of flag variables that must match exactly, and their
33 names for the error message. The possible values for *flag_var must
34 fit in a 'signed char'. */
35
36static const struct c_pch_matching
37{
38 int *flag_var;
39 const char *flag_name;
40} pch_matching[] = {
41 { &flag_exceptions, "-fexceptions" },
42};
43
44enum {
45 MATCH_SIZE = ARRAY_SIZE (pch_matching)
46};
47
48/* The value of the checksum in the dummy compiler that is actually
49 checksummed. That compiler should never be run. */
50static const char no_checksum[16] = { 0 };
51
52/* Information about flags and suchlike that affect PCH validity.
53
54 Before this structure is read, both an initial 8-character identification
55 string, and a 16-byte checksum, have been read and validated. */
56
57struct c_pch_validity
58{
59 unsigned char debug_info_type;
60 signed char match[MATCH_SIZE];
61 void (*pch_init) (void);
62 size_t target_data_length;
63};
64
65#define IDENT_LENGTH 8
66
67/* The file we'll be writing the PCH to. */
68static FILE *pch_outfile;
69
70static const char *get_ident (void);
71
72/* Compute an appropriate 8-byte magic number for the PCH file, so that
73 utilities like file(1) can identify it, and so that GCC can quickly
74 ignore non-PCH files and PCH files that are of a completely different
75 format. */
76
77static const char *
78get_ident (void)
79{
80 static char result[IDENT_LENGTH];
81 static const char templ[] = "gpch.014";
82 static const char c_language_chars[] = "Co+O";
83
84 memcpy (result, templ, IDENT_LENGTH);
85 result[4] = c_language_chars[c_language];
86
87 return result;
88}
89
90/* Whether preprocessor state should be saved by pch_init. */
91
92static bool pch_ready_to_save_cpp_state = false;
93
94/* Prepare to write a PCH file, if one is being written. This is
95 called at the start of compilation. */
96
97void
98pch_init (void)
99{
100 FILE *f;
101 struct c_pch_validity v;
102 void *target_validity;
103 static const char partial_pch[] = "gpcWrite";
104
105 if (!pch_file)
106 return;
107
108 f = fopen (pch_file, "w+b");
109 if (f == NULL)
110 fatal_error (input_location, "can%'t create precompiled header %s: %m",
111 pch_file);
112 pch_outfile = f;
113
114 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
115
116 memset (&v, '\0', sizeof (v));
117 v.debug_info_type = write_symbols;
118 {
119 size_t i;
120 for (i = 0; i < MATCH_SIZE; i++)
121 {
122 v.match[i] = *pch_matching[i].flag_var;
123 gcc_assert (v.match[i] == *pch_matching[i].flag_var);
124 }
125 }
126 v.pch_init = &pch_init;
127 target_validity = targetm.get_pch_validity (&v.target_data_length);
128
129 if (fwrite (partial_pch, IDENT_LENGTH, 1, f) != 1
130 || fwrite (executable_checksum, 16, 1, f) != 1
131 || fwrite (&v, sizeof (v), 1, f) != 1
132 || fwrite (target_validity, v.target_data_length, 1, f) != 1)
133 fatal_error (input_location, "can%'t write to %s: %m", pch_file);
134
135 /* Let the debugging format deal with the PCHness. */
136 (*debug_hooks->handle_pch) (0);
137
138 if (pch_ready_to_save_cpp_state)
139 pch_cpp_save_state ();
140
141 XDELETE (target_validity);
142}
143
144/* Whether preprocessor state has been saved in a PCH file. */
145
146static bool pch_cpp_state_saved = false;
147
148/* Save preprocessor state in a PCH file, after implicitly included
149 headers have been read. If the PCH file has not yet been opened,
150 record that state should be saved when it is opened. */
151
152void
153pch_cpp_save_state (void)
154{
155 if (!pch_cpp_state_saved)
156 {
157 if (pch_outfile)
158 {
159 cpp_save_state (parse_in, pch_outfile);
160 pch_cpp_state_saved = true;
161 }
162 else
163 pch_ready_to_save_cpp_state = true;
164 }
165}
166
167/* Write the PCH file. This is called at the end of a compilation which
168 will produce a PCH file. */
169
170void
171c_common_write_pch (void)
172{
173 timevar_push (TV_PCH_SAVE);
174
175 targetm.prepare_pch_save ();
176
177 (*debug_hooks->handle_pch) (1);
178
179 prepare_target_option_nodes_for_pch ();
180
181 cpp_write_pch_deps (parse_in, pch_outfile);
182
183 gt_pch_save (pch_outfile);
184
185 timevar_push (TV_PCH_CPP_SAVE);
186 cpp_write_pch_state (parse_in, pch_outfile);
187 timevar_pop (TV_PCH_CPP_SAVE);
188
189 if (fseek (pch_outfile, 0, SEEK_SET) != 0
190 || fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1)
191 fatal_error (input_location, "can%'t write %s: %m", pch_file);
192
193 fclose (pch_outfile);
194
195 timevar_pop (TV_PCH_SAVE);
196}
197
198/* Check the PCH file called NAME, open on FD, to see if it can be
199 used in this compilation. Return 1 if valid, 0 if the file can't
200 be used now but might be if it's seen later in the compilation, and
201 2 if this file could never be used in the compilation. */
202
203int
204c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)
205{
206 int sizeread;
207 int result;
208 char ident[IDENT_LENGTH + 16];
209 const char *pch_ident;
210 struct c_pch_validity v;
211
212 /* Perform a quick test of whether this is a valid
213 precompiled header for the current language. */
214
215 gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
216
217 sizeread = read (fd, ident, IDENT_LENGTH + 16);
218 if (sizeread == -1)
219 fatal_error (input_location, "can%'t read %s: %m", name);
220 else if (sizeread != IDENT_LENGTH + 16)
221 {
222 if (cpp_get_options (pfile)->warn_invalid_pch)
223 cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file",
224 name);
225 return 2;
226 }
227
228 pch_ident = get_ident();
229 if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
230 {
231 if (cpp_get_options (pfile)->warn_invalid_pch)
232 {
233 if (memcmp (ident, pch_ident, 5) == 0)
234 /* It's a PCH, for the right language, but has the wrong version.
235 */
236 cpp_error (pfile, CPP_DL_WARNING,
237 "%s: not compatible with this GCC version", name);
238 else if (memcmp (ident, pch_ident, 4) == 0)
239 /* It's a PCH for the wrong language. */
240 cpp_error (pfile, CPP_DL_WARNING, "%s: not for %s", name,
241 lang_hooks.name);
242 else
243 /* Not any kind of PCH. */
244 cpp_error (pfile, CPP_DL_WARNING, "%s: not a PCH file", name);
245 }
246 return 2;
247 }
248 if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
249 {
250 if (cpp_get_options (pfile)->warn_invalid_pch)
251 cpp_error (pfile, CPP_DL_WARNING,
252 "%s: created by a different GCC executable", name);
253 return 2;
254 }
255
256 /* At this point, we know it's a PCH file created by this
257 executable, so it ought to be long enough that we can read a
258 c_pch_validity structure. */
259 if (read (fd, &v, sizeof (v)) != sizeof (v))
260 fatal_error (input_location, "can%'t read %s: %m", name);
261
262 /* The allowable debug info combinations are that either the PCH file
263 was built with the same as is being used now, or the PCH file was
264 built for some kind of debug info but now none is in use. */
265 if (v.debug_info_type != write_symbols
266 && write_symbols != NO_DEBUG)
267 {
268 if (cpp_get_options (pfile)->warn_invalid_pch)
269 cpp_error (pfile, CPP_DL_WARNING,
270 "%s: created with -g%s, but used with -g%s", name,
271 debug_type_names[v.debug_info_type],
272 debug_type_names[write_symbols]);
273 return 2;
274 }
275
276 /* Check flags that must match exactly. */
277 {
278 size_t i;
279 for (i = 0; i < MATCH_SIZE; i++)
280 if (*pch_matching[i].flag_var != v.match[i])
281 {
282 if (cpp_get_options (pfile)->warn_invalid_pch)
283 cpp_error (pfile, CPP_DL_WARNING,
284 "%s: settings for %s do not match", name,
285 pch_matching[i].flag_name);
286 return 2;
287 }
288 }
289
290 /* If the text segment was not loaded at the same address as it was
291 when the PCH file was created, function pointers loaded from the
292 PCH will not be valid. We could in theory remap all the function
293 pointers, but no support for that exists at present.
294 Since we have the same executable, it should only be necessary to
295 check one function. */
296 if (v.pch_init != &pch_init)
297 {
298 if (cpp_get_options (pfile)->warn_invalid_pch)
299 cpp_error (pfile, CPP_DL_WARNING,
300 "%s: had text segment at different address", name);
301 return 2;
302 }
303
304 /* Check the target-specific validity data. */
305 {
306 void *this_file_data = xmalloc (v.target_data_length);
307 const char *msg;
308
309 if ((size_t) read (fd, this_file_data, v.target_data_length)
310 != v.target_data_length)
311 fatal_error (input_location, "can%'t read %s: %m", name);
312 msg = targetm.pch_valid_p (this_file_data, v.target_data_length);
313 free (this_file_data);
314 if (msg != NULL)
315 {
316 if (cpp_get_options (pfile)->warn_invalid_pch)
317 cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
318 return 2;
319 }
320 }
321
322 /* Check the preprocessor macros are the same as when the PCH was
323 generated. */
324
325 result = cpp_valid_state (pfile, name, fd);
326 if (result == -1)
327 return 2;
328 else
329 return result == 0;
330}
331
332/* If non-NULL, this function is called after a precompile header file
333 is loaded. */
334void (*lang_post_pch_load) (void);
335
336/* Load in the PCH file NAME, open on FD. It was originally searched for
337 by ORIG_NAME. */
338
339void
340c_common_read_pch (cpp_reader *pfile, const char *name,
341 int fd, const char *orig_name ATTRIBUTE_UNUSED)
342{
343 FILE *f;
344 struct save_macro_data *smd;
345 expanded_location saved_loc;
346 bool saved_trace_includes;
347
348 timevar_push (TV_PCH_RESTORE);
349
350 f = fdopen (fd, "rb");
351 if (f == NULL)
352 {
353 cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
354 close (fd);
355 goto end;
356 }
357
358 cpp_get_callbacks (parse_in)->valid_pch = NULL;
359
360 /* Save the location and then restore it after reading the PCH. */
361 saved_loc = expand_location (line_table->highest_line);
362 saved_trace_includes = line_table->trace_includes;
363
364 timevar_push (TV_PCH_CPP_RESTORE);
365 cpp_prepare_state (pfile, &smd);
366 timevar_pop (TV_PCH_CPP_RESTORE);
367
368 gt_pch_restore (f);
369 cpp_set_line_map (pfile, line_table);
370 rebuild_location_adhoc_htab (line_table);
371
372 timevar_push (TV_PCH_CPP_RESTORE);
373 if (cpp_read_state (pfile, name, f, smd) != 0)
374 {
375 fclose (f);
376 timevar_pop (TV_PCH_CPP_RESTORE);
377 goto end;
378 }
379 timevar_pop (TV_PCH_CPP_RESTORE);
380
381
382 fclose (f);
383
384 line_table->trace_includes = saved_trace_includes;
385 linemap_add (line_table, LC_ENTER, 0, saved_loc.file, saved_loc.line);
386
387 /* Give the front end a chance to take action after a PCH file has
388 been loaded. */
389 if (lang_post_pch_load)
390 (*lang_post_pch_load) ();
391
392end:
393 timevar_pop (TV_PCH_RESTORE);
394}
395
396/* Indicate that no more PCH files should be read. */
397
398void
399c_common_no_more_pch (void)
400{
401 if (cpp_get_callbacks (parse_in)->valid_pch)
402 {
403 cpp_get_callbacks (parse_in)->valid_pch = NULL;
404 host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
405 }
406}
407
408/* Handle #pragma GCC pch_preprocess, to load in the PCH file. */
409
410void
411c_common_pch_pragma (cpp_reader *pfile, const char *name)
412{
413 int fd;
414
415 if (!cpp_get_options (pfile)->preprocessed)
416 {
417 error ("pch_preprocess pragma should only be used with -fpreprocessed");
418 inform (input_location, "use #include instead");
419 return;
420 }
421
422 fd = open (name, O_RDONLY | O_BINARY, 0666);
423 if (fd == -1)
424 fatal_error (input_location, "%s: couldn%'t open PCH file: %m", name);
425
426 if (c_common_valid_pch (pfile, name, fd) != 1)
427 {
428 if (!cpp_get_options (pfile)->warn_invalid_pch)
429 inform (input_location, "use -Winvalid-pch for more information");
430 fatal_error (input_location, "%s: PCH file was invalid", name);
431 }
432
433 c_common_read_pch (pfile, name, fd, name);
434
435 close (fd);
436}
437
438