gcc/c-pch.c

   1 /* Precompiled header implementation for the C languages.
   2    Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007 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       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
 371   f = fdopen (fd, "rb");
 372   if (f == NULL)
 373     {
 374       cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
 375       return;
 376     }
 377
 378   cpp_get_callbacks (parse_in)->valid_pch = NULL;
 379
 380   if (fread (&h, sizeof (h), 1, f) != 1)
 381     {
 382       cpp_errno (pfile, CPP_DL_ERROR, "reading");
 383       return;
 384     }
 385
 386   if (!flag_preprocess_only)
 387     {
 388       unsigned long written;
 389       char * buf = XNEWVEC (char, 16384);
 390
 391       for (written = 0; written < h.asm_size; )
 392         {
 393           long size = h.asm_size - written;
 394           if (size > 16384)
 395             size = 16384;
 396           if (fread (buf, size, 1, f) != 1
 397               || fwrite (buf, size, 1, asm_out_file) != 1)
 398             cpp_errno (pfile, CPP_DL_ERROR, "reading");
 399           written += size;
 400         }
 401       free (buf);
 402     }
 403   else
 404     {
 405       /* If we're preprocessing, don't write to a NULL
 406          asm_out_file.  */
 407       if (fseek (f, h.asm_size, SEEK_CUR) != 0)
 408         cpp_errno (pfile, CPP_DL_ERROR, "seeking");
 409     }
 410
 411   /* Save the location and then restore it after reading the PCH.  */
 412 #ifdef USE_MAPPED_LOCATION
 413   saved_loc = expand_location (line_table->highest_line);
 414 #else
 415   {
 416     const struct line_map *map = linemap_lookup (line_table,
 417                                                  line_table->highest_line);
 418     saved_loc.file = map->to_file;
 419     saved_loc.line = SOURCE_LINE (map, line_table->highest_line);
 420   }
 421 #endif
 422
 423   cpp_prepare_state (pfile, &smd);
 424
 425   gt_pch_restore (f);
 426
 427   if (cpp_read_state (pfile, name, f, smd) != 0)
 428     return;
 429
 430   fclose (f);
 431
 432   cpp_set_line_map (pfile, line_table);
 433   linemap_add (line_table, LC_RENAME, 0, saved_loc.file, saved_loc.line);
 434
 435   /* Give the front end a chance to take action after a PCH file has
 436      been loaded.  */
 437   if (lang_post_pch_load)
 438     (*lang_post_pch_load) ();
 439 }
 440
 441 /* Indicate that no more PCH files should be read.  */
 442
 443 void
 444 c_common_no_more_pch (void)
 445 {
 446   if (cpp_get_callbacks (parse_in)->valid_pch)
 447     {
 448       cpp_get_callbacks (parse_in)->valid_pch = NULL;
 449       host_hooks.gt_pch_use_address (NULL, 0, -1, 0);
 450     }
 451 }
 452
 453 /* Handle #pragma GCC pch_preprocess, to load in the PCH file.  */
 454
 455 #ifndef O_BINARY
 456 # define O_BINARY 0
 457 #endif
 458
 459 void
 460 c_common_pch_pragma (cpp_reader *pfile, const char *name)
 461 {
 462   int fd;
 463
 464   if (!cpp_get_options (pfile)->preprocessed)
 465     {
 466       error ("pch_preprocess pragma should only be used with -fpreprocessed");
 467       inform ("use #include instead");
 468       return;
 469     }
 470
 471   fd = open (name, O_RDONLY | O_BINARY, 0666);
 472   if (fd == -1)
 473     fatal_error ("%s: couldn%'t open PCH file: %m", name);
 474
 475   if (c_common_valid_pch (pfile, name, fd) != 1)
 476     {
 477       if (!cpp_get_options (pfile)->warn_invalid_pch)
 478         inform ("use -Winvalid-pch for more information");
 479       fatal_error ("%s: PCH file was invalid", name);
 480     }
 481
 482   c_common_read_pch (pfile, name, fd, name);
 483
 484   close (fd);
 485 }
 486
 487 /* Print out executable_checksum[].  */
 488
 489 void
 490 c_common_print_pch_checksum (FILE *f)
 491 {
 492   int i;
 493   fputs ("Compiler executable checksum: ", f);
 494   for (i = 0; i < 16; i++)
 495     fprintf (f, "%02x", executable_checksum[i]);
 496   putc ('\n', f);
 497 }