1 | /* Precompiled header implementation for the C languages. |
2 | Copyright (C) 2000-2017 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 "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 | |
36 | static const struct c_pch_matching |
37 | { |
38 | int *flag_var; |
39 | const char *flag_name; |
40 | } pch_matching[] = { |
41 | { &flag_exceptions, "-fexceptions" }, |
42 | }; |
43 | |
44 | enum { |
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. */ |
50 | static 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 | |
57 | struct 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. */ |
68 | static FILE *pch_outfile; |
69 | |
70 | static 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 | |
77 | static const char * |
78 | get_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 | |
92 | static 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 | |
97 | void |
98 | pch_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 | |
146 | static 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 | |
152 | void |
153 | pch_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 | |
170 | void |
171 | c_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 | |
203 | int |
204 | c_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. */ |
334 | void (*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 | |
339 | void |
340 | c_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 | |
392 | end: |
393 | timevar_pop (TV_PCH_RESTORE); |
394 | } |
395 | |
396 | /* Indicate that no more PCH files should be read. */ |
397 | |
398 | void |
399 | c_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 | |
410 | void |
411 | c_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 | |