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 };
  49
  50 enum {
  51   MATCH_SIZE = ARRAY_SIZE (pch_matching)
  52 };
  53
  54 /* The value of the checksum in the dummy compiler that is actually
  55    checksummed.  That compiler should never be run.  */
  56 static const char no_checksum[16] = { 0 };
  57
  58 /* Information about flags and suchlike that affect PCH validity.
  59
  60    Before this structure is read, both an initial 8-character identification
  61    string, and a 16-byte checksum, have been read and validated.  */
  62
  63 struct c_pch_validity
  64 {
  65   unsigned char debug_info_type;
  66   signed char match[MATCH_SIZE];
  67   void (*pch_init) (void);
  68   size_t target_data_length;
  69 };
  70
  71 struct c_pch_header
  72 {
  73   unsigned long asm_size;
  74 };
  75
  76 #define IDENT_LENGTH 8
  77
  78 /* The file we'll be writing the PCH to.  */
  79 static FILE *pch_outfile;
  80
  81 /* The position in the assembler output file when pch_init was called.  */
  82 static long asm_file_startpos;
  83
  84 static const char *get_ident (void);
  85
  86 /* Compute an appropriate 8-byte magic number for the PCH file, so that
  87    utilities like file(1) can identify it, and so that GCC can quickly
  88    ignore non-PCH files and PCH files that are of a completely different
  89    format.  */
  90
  91 static const char *
  92 get_ident (void)
  93 {
  94   static char result[IDENT_LENGTH];
  95   static const char templ[IDENT_LENGTH] = "gpch.013";
  96   static const char c_language_chars[] = "Co+O";
  97
  98   memcpy (result, templ, IDENT_LENGTH);
  99   result[4] = c_language_chars[c_language];
 100
 101   return result;
 102 }
 103
 104 /* Prepare to write a PCH file, if one is being written.  This is
 105    called at the start of compilation.
 106
 107    Also, print out the executable checksum if -fverbose-asm is in effect.  */
 108
 109 void
 110 pch_init (void)
 111 {
 112   FILE *f;
 113   struct c_pch_validity v;
 114   void *target_validity;
 115   static const char partial_pch[IDENT_LENGTH] = "gpcWrite";
 116
 117 #ifdef ASM_COMMENT_START
 118   if (flag_verbose_asm)
 119     {
 120       fprintf (asm_out_file, "%s ", ASM_COMMENT_START);
 121       c_common_print_pch_checksum (asm_out_file);
 122       fputc ('\n', asm_out_file);
 123     }
 124 #endif
 125
 126   if (!pch_file)
 127     return;
 128
 129   f = fopen (pch_file, "w+b");
 130   if (f == NULL)
 131     fatal_error ("can%'t create precompiled header %s: %m", pch_file);
 132   pch_outfile = f;
 133
 134   gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
 135
 136   v.debug_info_type = write_symbols;
 137   {
 138     size_t i;
 139     for (i = 0; i < MATCH_SIZE; i++)
 140       {
 141         v.match[i] = *pch_matching[i].flag_var;
 142         gcc_assert (v.match[i] == *pch_matching[i].flag_var);
 143       }
 144   }
 145   v.pch_init = &pch_init;
 146   target_validity = targetm.get_pch_validity (&v.target_data_length);
 147
 148   if (fwrite (partial_pch, IDENT_LENGTH, 1, f) != 1
 149       || fwrite (executable_checksum, 16, 1, f) != 1
 150       || fwrite (&v, sizeof (v), 1, f) != 1
 151       || fwrite (target_validity, v.target_data_length, 1, f) != 1)
 152     fatal_error ("can%'t write to %s: %m", pch_file);
 153
 154   /* We need to be able to re-read the output.  */
 155   /* The driver always provides a valid -o option.  */
 156   if (asm_file_name == NULL
 157       || strcmp (asm_file_name, "-") == 0)
 158     fatal_error ("%qs is not a valid output file", asm_file_name);
 159
 160   asm_file_startpos = ftell (asm_out_file);
 161
 162   /* Let the debugging format deal with the PCHness.  */
 163   (*debug_hooks->handle_pch) (0);
 164
 165   cpp_save_state (parse_in, f);
 166 }
 167
 168 /* Write the PCH file.  This is called at the end of a compilation which
 169    will produce a PCH file.  */
 170
 171 void
 172 c_common_write_pch (void)
 173 {
 174   char *buf;
 175   long asm_file_end;
 176   long written;
 177   struct c_pch_header h;
 178
 179   (*debug_hooks->handle_pch) (1);
 180
 181   cpp_write_pch_deps (parse_in, pch_outfile);
 182
 183   asm_file_end = ftell (asm_out_file);
 184   h.asm_size = asm_file_end - asm_file_startpos;
 185
 186   if (fwrite (&h, sizeof (h), 1, pch_outfile) != 1)
 187     fatal_error ("can%'t write %s: %m", pch_file);
 188
 189   buf = XNEWVEC (char, 16384);
 190
 191   if (fseek (asm_out_file, asm_file_startpos, SEEK_SET) != 0)
 192     fatal_error ("can%'t seek in %s: %m", asm_file_name);
 193
 194   for (written = asm_file_startpos; written < asm_file_end; )
 195     {
 196       long size = asm_file_end - written;
 197       if (size > 16384)
 198         size = 16384;
 199       if (fread (buf, size, 1, asm_out_file) != 1)
 200         fatal_error ("can%'t read %s: %m", asm_file_name);
 201       if (fwrite (buf, size, 1, pch_outfile) != 1)
 202         fatal_error ("can%'t write %s: %m", pch_file);
 203       written += size;
 204     }
 205   free (buf);
 206   /* asm_out_file can be written afterwards, so fseek to clear
 207      _IOREAD flag.  */
 208   if (fseek (asm_out_file, 0, SEEK_END) != 0)
 209     fatal_error ("can%'t seek in %s: %m", asm_file_name);
 210
 211   gt_pch_save (pch_outfile);
 212   cpp_write_pch_state (parse_in, pch_outfile);
 213
 214   if (fseek (pch_outfile, 0, SEEK_SET) != 0
 215       || fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1)
 216     fatal_error ("can%'t write %s: %m", pch_file);
 217
 218   fclose (pch_outfile);
 219 }
 220
 221 /* Check the PCH file called NAME, open on FD, to see if it can be
 222    used in this compilation.  Return 1 if valid, 0 if the file can't
 223    be used now but might be if it's seen later in the compilation, and
 224    2 if this file could never be used in the compilation.  */
 225
 226 int
 227 c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)
 228 {
 229   int sizeread;
 230   int result;
 231   char ident[IDENT_LENGTH + 16];
 232   const char *pch_ident;
 233   struct c_pch_validity v;
 234
 235   /* Perform a quick test of whether this is a valid
 236      precompiled header for the current language.  */
 237
 238   gcc_assert (memcmp (executable_checksum, no_checksum, 16) != 0);
 239
 240   sizeread = read (fd, ident, IDENT_LENGTH + 16);
 241   if (sizeread == -1)
 242     fatal_error ("can%'t read %s: %m", name);
 243   else if (sizeread != IDENT_LENGTH + 16)
 244     {
 245       if (cpp_get_options (pfile)->warn_invalid_pch)
 246         cpp_error (pfile, CPP_DL_WARNING, "%s: too short to be a PCH file",
 247                    name);
 248       return 2;
 249     }
 250
 251   pch_ident = get_ident();
 252   if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
 253     {
 254       if (cpp_get_options (pfile)->warn_invalid_pch)
 255         {
 256           if (memcmp (ident, pch_ident, 5) == 0)
 257             /* It's a PCH, for the right language, but has the wrong version.
 258              */
 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);
 268         }
 269       return 2;
 270     }
 271   if (memcmp (ident + IDENT_LENGTH, executable_checksum, 16) != 0)
 272     {
 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;
 277     }
 278
 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);
 284
 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)
 290     {
 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;
 297     }
 298
 299   /* Check flags that must match exactly.  */
 300   {
 301     size_t i;
 302     for (i = 0; i < MATCH_SIZE; i++)
 303       if (*pch_matching[i].flag_var != v.match[i])
 304         {
 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;
 310         }
 311   }
 312
 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)
 320     {
 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;
 325     }
 326
 327   /* Check the target-specific validity data.  */
 328   {
 329     void *this_file_data = xmalloc (v.target_data_length);
 330     const char *msg;
 331
 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)
 338       {
 339         if (cpp_get_options (pfile)->warn_invalid_pch)
 340           cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);
 341         return 2;
 342       }
 343   }
 344
 345   /* Check the preprocessor macros are the same as when the PCH was
 346      generated.  */
 347
 348   result = cpp_valid_state (pfile, name, fd);
 349   if (result == -1)
 350     return 2;
 351   else
 352     return result == 0;
 353 }
 354
 355 /* If non-NULL, this function is called after a precompile header file
 356    is loaded.  */
 357 void (*lang_post_pch_load) (void);
 358
 359 /* Load in the PCH file NAME, open on FD.  It was originally searched for
 360    by ORIG_NAME.  */
 361
 362 void
 363 c_common_read_pch (cpp_reader *pfile, const char *name,
 364                    int fd, const char *orig_name ATTRIBUTE_UNUSED)
 365 {
 366   FILE *f;
 367   struct c_pch_header h;
 368   struct save_macro_data *smd;
 369   expanded_location saved_loc;
 370   bool saved_trace_includes;
 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   saved_trace_includes = line_table->trace_includes;
 417
 418   cpp_prepare_state (pfile, &smd);
 419
 420   gt_pch_restore (f);
 421
 422   if (cpp_read_state (pfile, name, f, smd) != 0)
 423     {
 424       fclose (f);
 425       return;
 426     }
 427
 428   fclose (f);
 429
 430   line_table->trace_includes = saved_trace_includes;
 431   cpp_set_line_map (pfile, line_table);
 432   linemap_add (line_table, LC_RENAME, 0, saved_loc.file, saved_loc.line);
 433
 434   /* Give the front end a chance to take action after a PCH file has
 435      been loaded.  */
 436   if (lang_post_pch_load)
 437     (*lang_post_pch_load) ();
 438 }
 439
 440 /* Indicate that no more PCH files should be read.  */
 441
 442 void
 443 c_common_no_more_pch (void)
 444 {
 445   if (cpp_get_callbacks (parse_in)->valid_pch)
 446     {
 447       cpp_get_callbacks (parse_in)->valid_pch = NULL;
 448       host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
 449     }
 450 }
 451
 452 /* Handle #pragma GCC pch_preprocess, to load in the PCH file.  */
 453
 454 #ifndef O_BINARY
 455 # define O_BINARY 0
 456 #endif
 457
 458 void
 459 c_common_pch_pragma (cpp_reader *pfile, const char *name)
 460 {
 461   int fd;
 462
 463   if (!cpp_get_options (pfile)->preprocessed)
 464     {
 465       error ("pch_preprocess pragma should only be used with -fpreprocessed");
 466       inform (input_location, "use #include instead");
 467       return;
 468     }
 469
 470   fd = open (name, O_RDONLY | O_BINARY, 0666);
 471   if (fd == -1)
 472     fatal_error ("%s: couldn%'t open PCH file: %m", name);
 473
 474   if (c_common_valid_pch (pfile, name, fd) != 1)
 475     {
 476       if (!cpp_get_options (pfile)->warn_invalid_pch)
 477         inform (input_location, "use -Winvalid-pch for more information");
 478       fatal_error ("%s: PCH file was invalid", name);
 479     }
 480
 481   c_common_read_pch (pfile, name, fd, name);
 482
 483   close (fd);
 484 }
 485
 486 /* Print out executable_checksum[].  */
 487
 488 void
 489 c_common_print_pch_checksum (FILE *f)
 490 {
 491   int i;
 492   fputs ("Compiler executable checksum: ", f);
 493   for (i = 0; i < 16; i++)
 494     fprintf (f, "%02x", executable_checksum[i]);
 495   putc ('\n', f);
 496 }