gcc/c-pch.c

   1 /* Precompiled header implementation for the C languages.
   2    Copyright (C) 2000, 2002 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 2, 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 COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.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
  35 struct c_pch_validity
  36 {
  37   unsigned char debug_info_type;
  38 };
  39
  40 struct c_pch_header
  41 {
  42   unsigned long asm_size;
  43 };
  44
  45 #define IDENT_LENGTH 8
  46
  47 static FILE *pch_outfile;
  48
  49 extern char *asm_file_name;
  50 static long asm_file_startpos;
  51
  52 static const char * get_ident PARAMS((void));
  53
  54 /* Compute an appropriate 8-byte magic number for the PCH file, so that
  55    utilities like file(1) can identify it, and so that GCC can quickly
  56    ignore non-PCH files and PCH files that are of a completely different
  57    format.  */
  58
  59 static const char *
  60 get_ident()
  61 {
  62   static char result[IDENT_LENGTH];
  63   static const char template[IDENT_LENGTH] = "gpch.011";
  64
  65   memcpy (result, template, IDENT_LENGTH);
  66   if (c_language == clk_c)
  67     result[4] = flag_objc ? 'o' : 'C';
  68   else if (c_language == clk_cplusplus)
  69     result[4] = flag_objc ? 'O' : '+';
  70   else
  71     abort ();
  72   return result;
  73 }
  74
  75 /* Prepare to write a PCH file.  This is called at the start of
  76    compilation.  */
  77
  78 void
  79 pch_init ()
  80 {
  81   FILE *f;
  82   struct c_pch_validity v;
  83
  84   if (! pch_file)
  85     return;
  86
  87   f = fopen (pch_file, "w+b");
  88   if (f == NULL)
  89     fatal_error ("can't open %s: %m", pch_file);
  90   pch_outfile = f;
  91
  92   v.debug_info_type = write_symbols;
  93   if (fwrite (get_ident(), IDENT_LENGTH, 1, f) != 1
  94       || fwrite (&v, sizeof (v), 1, f) != 1)
  95     fatal_error ("can't write to %s: %m", pch_file);
  96
  97   /* We need to be able to re-read the output.  */
  98   /* The driver always provides a valid -o option.  */
  99   if (asm_file_name == NULL
 100       || strcmp (asm_file_name, "-") == 0)
 101     fatal_error ("`%s' is not a valid output file", asm_file_name);
 102
 103   asm_file_startpos = ftell (asm_out_file);
 104
 105   /* Let the debugging format deal with the PCHness.  */
 106   (*debug_hooks->handle_pch) (0);
 107
 108   cpp_save_state (parse_in, f);
 109 }
 110
 111 /* Write the PCH file.  This is called at the end of a compilation which
 112    will produce a PCH file.  */
 113
 114 void
 115 c_common_write_pch ()
 116 {
 117   char *buf;
 118   long asm_file_end;
 119   long written;
 120   struct c_pch_header h;
 121
 122   (*debug_hooks->handle_pch) (1);
 123
 124   cpp_write_pch_deps (parse_in, pch_outfile);
 125
 126   asm_file_end = ftell (asm_out_file);
 127   h.asm_size = asm_file_end - asm_file_startpos;
 128
 129   if (fwrite (&h, sizeof (h), 1, pch_outfile) != 1)
 130     fatal_error ("can't write %s: %m", pch_file);
 131
 132   buf = xmalloc (16384);
 133   fflush (asm_out_file);
 134
 135   if (fseek (asm_out_file, asm_file_startpos, SEEK_SET) != 0)
 136     fatal_error ("can't seek in %s: %m", asm_file_name);
 137
 138   for (written = asm_file_startpos; written < asm_file_end; )
 139     {
 140       long size = asm_file_end - written;
 141       if (size > 16384)
 142         size = 16384;
 143       if (fread (buf, size, 1, asm_out_file) != 1)
 144         fatal_error ("can't read %s: %m", asm_file_name);
 145       if (fwrite (buf, size, 1, pch_outfile) != 1)
 146         fatal_error ("can't write %s: %m", pch_file);
 147       written += size;
 148     }
 149   free (buf);
 150
 151   gt_pch_save (pch_outfile);
 152   cpp_write_pch_state (parse_in, pch_outfile);
 153
 154   fclose (pch_outfile);
 155 }
 156
 157 /* Check the PCH file called NAME, open on FD, to see if it can be used
 158    in this compilation.  */
 159
 160 int
 161 c_common_valid_pch (pfile, name, fd)
 162      cpp_reader *pfile;
 163      const char *name;
 164      int fd;
 165 {
 166   int sizeread;
 167   int result;
 168   char ident[IDENT_LENGTH];
 169   const char *pch_ident;
 170   struct c_pch_validity v;
 171
 172   if (! allow_pch)
 173     return 2;
 174
 175   /* Perform a quick test of whether this is a valid
 176      precompiled header for the current language.  */
 177
 178   sizeread = read (fd, ident, IDENT_LENGTH);
 179   if (sizeread == -1)
 180     fatal_error ("can't read %s: %m", name);
 181   else if (sizeread != IDENT_LENGTH)
 182     return 2;
 183
 184   pch_ident = get_ident();
 185   if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)
 186     {
 187       if (cpp_get_options (pfile)->warn_invalid_pch)
 188         {
 189           if (memcmp (ident, pch_ident, 5) == 0)
 190             /* It's a PCH, for the right language, but has the wrong version.
 191              */
 192             cpp_error (pfile, DL_WARNING,
 193                        "%s: not compatible with this GCC version", name);
 194           else if (memcmp (ident, pch_ident, 4) == 0)
 195             /* It's a PCH for the wrong language.  */
 196             cpp_error (pfile, DL_WARNING, "%s: not for %s", name,
 197                        lang_hooks.name);
 198           else
 199             /* Not any kind of PCH.  */
 200             cpp_error (pfile, DL_WARNING, "%s: not a PCH file", name);
 201         }
 202       return 2;
 203     }
 204
 205   if (read (fd, &v, sizeof (v)) != sizeof (v))
 206     fatal_error ("can't read %s: %m", name);
 207
 208   /* The allowable debug info combinations are that either the PCH file
 209      was built with the same as is being used now, or the PCH file was
 210      built for some kind of debug info but now none is in use.  */
 211   if (v.debug_info_type != write_symbols
 212       && write_symbols != NO_DEBUG)
 213     {
 214       if (cpp_get_options (pfile)->warn_invalid_pch)
 215         cpp_error (pfile, DL_WARNING,
 216                    "%s: created with -g%s, but used with -g%s", name,
 217                    debug_type_names[v.debug_info_type],
 218                    debug_type_names[write_symbols]);
 219       return 2;
 220     }
 221
 222   /* Check the preprocessor macros are the same as when the PCH was
 223      generated.  */
 224
 225   result = cpp_valid_state (pfile, name, fd);
 226   if (result == -1)
 227     return 2;
 228   else
 229     return result == 0;
 230 }
 231
 232 /* Load in the PCH file NAME, open on FD.  It was originally searched for
 233    by ORIG_NAME.  */
 234
 235 void
 236 c_common_read_pch (pfile, name, fd, orig_name)
 237      cpp_reader *pfile;
 238      const char *name;
 239      int fd;
 240      const char *orig_name ATTRIBUTE_UNUSED;
 241 {
 242   FILE *f;
 243   struct c_pch_header h;
 244   char *buf;
 245   unsigned long written;
 246   struct save_macro_data *smd;
 247
 248   f = fdopen (fd, "rb");
 249   if (f == NULL)
 250     {
 251       cpp_errno (pfile, DL_ERROR, "calling fdopen");
 252       return;
 253     }
 254
 255   allow_pch = 0;
 256
 257   if (fread (&h, sizeof (h), 1, f) != 1)
 258     {
 259       cpp_errno (pfile, DL_ERROR, "reading");
 260       return;
 261     }
 262
 263   buf = xmalloc (16384);
 264   for (written = 0; written < h.asm_size; )
 265     {
 266       long size = h.asm_size - written;
 267       if (size > 16384)
 268         size = 16384;
 269       if (fread (buf, size, 1, f) != 1
 270           || fwrite (buf, size, 1, asm_out_file) != 1)
 271         cpp_errno (pfile, DL_ERROR, "reading");
 272       written += size;
 273     }
 274   free (buf);
 275
 276   cpp_prepare_state (pfile, &smd);
 277
 278   gt_pch_restore (f);
 279
 280   if (cpp_read_state (pfile, name, f, smd) != 0)
 281     return;
 282
 283   fclose (f);
 284 }