Studying note of GCC-3.4.6 source (32)

4.1.3.1.2. Read in file
Above at line 439, if the file has been found and opened successfully, _cpp_find_file returns the corresponding _cpp_file object, and refered by pfile->main_file. So at this point, it can begin read in the file content.

cpp_read_main_file (continue)

473 _cpp_stack_file (pfile, pfile->main_file, false);
474
475 /* For foo.i, read the original filename foo.c now, for the benefit
476 of the front ends. */
477 if (CPP_OPTION (pfile, preprocessed))
478 {
479 read_original_filename (pfile);
480 if (!pfile->map)
481 return NULL;
482 fname = pfile->map->to_file;
483 }
484 return fname;
485 }

In below functions, parameter import is true, if the file is included by #import directive. About the #import directive, [6] gives out below explaination.

GNU CPP supports two more ways of indicating that a header file should be read only once. Neither one is as portable as a wrapper ‘#ifdef’, and we recommend you do not use them in new programs. In the Objective-C language, there is a variant of ‘#include’ called ‘#import’ which includes a file, but does so at most once. If you use ‘#import’ instead of ‘#include’, then you don’t need the conditionals inside the header file to prevent multiple inclusion of the cntents. GCC premits the use of ‘#import’ in C and C++ as well as Objective-C. However, it is not in standard Cor C++ and should therefore not be used by portable programs. ‘#import’ is not a well designed feature. It requires the users of a header file to know that it should only be included once. It is much better for the header file’s implementor to write the file so that users don’t need to know this. Using a wrapper ‘#ifndef’ accomplishes this goal. In the present implementation, a single use of ‘#import’ will prevent the file from ever being read again, by either ‘#import’ or ‘#include’. You should not rely on this; do not use both ‘#import’ and ‘#include’ to refer to the same header file. Another way to prevent aheader file from being included more than once is with the ‘#pragma once’ directive. If ‘#pragm once’ is seen when scanning a header file, that file will never be read again, no matter what. ‘#pragma once’ does not have the problems that ‘#import’ does, but it is not recognize by all preprocessors, so you cannot rely on it in a portable program.

643 bool
644 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import) in cppfiles.c
645 {
646 cpp_buffer *buffer;
647 int sysp;
648
649 if (!should_stack_file (pfile, file, import))
640 return false;

Here, for file included by ‘#import’ directive, once_only, seen_once_only will be set at line 563 below in _cpp_mark_file_once_only, so next time the file read again, it will exit at line 556. Then at line 572 below, it checks if the file has a defined header guard.

549 static bool
550 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import) in cppfiles.c
551 {
552 _cpp_file *f;
553
554 /* Skip once-only files. */
555 if (file->once_only)
556 return false;
557
558 /* We must mark the file once-only if #import now, before header
559 guard checks. Otherwise, undefining the header guard might
560 cause the file to be re-stacked. */
561 if (import)
562 {
563 _cpp_mark_file_once_only (pfile, file);
564
565 /* Don't stack files that have been stacked before. */
566 if (file->stack_count)
567 return false;
568 }
569
570 /* Skip if the file had a header guard and the macro is defined.
571 PCH relies on this appearing before the PCH handler below. */
572 if (file->cmacro && file->cmacro->type == NT_MACRO)
573 return false;
574
575 /* Handle PCH files immediately; don't stack them. */
576 if (include_pch_p (file))
577 {
578 pfile->cb.read_pch (pfile, file->path, file->fd, file->pchname);
579 close (file->fd);
580 file->fd = -1;
581 return false;
582 }
4.1.3.1.2.1. Case of PCH file
Above at line 576, include_pch_p checks the field pch of _cpp_file to see if the file is PCH (precompiled header), this field is set in pch_open_file if the PCH file is validate.

375 void
376 c_common_read_pch (cpp_reader *pfile, const char *name, in c-pch.c
377 int fd, const char *orig_name ATTRIBUTE_UNUSED)
378 {
379 FILE *f;
380 struct c_pch_header h;
381 char *buf;
382 unsigned long written;
383 struct save_macro_data *smd;
384
385 f = fdopen (fd, "rb");
386 if (f == NULL)
387 {
388 cpp_errno (pfile, CPP_DL_ERROR, "calling fdopen");
389 return;
390 }
391
392 cpp_get_callbacks (parse_in)->valid_pch = NULL;
393
394 if (fread (&h, sizeof (h), 1, f) != 1)
395 {
396 cpp_errno (pfile, CPP_DL_ERROR, "reading");
397 return;
398 }
399
400 buf = xmalloc (16384);
401 for (written = 0; written < h.asm_size; )
402 {
403 long size = h.asm_size - written;
404 if (size > 16384)
405 size = 16384;
406 if (fread (buf, size, 1, f) != 1
407 || fwrite (buf, size, 1, asm_out_file) != 1)
408 cpp_errno (pfile, CPP_DL_ERROR, "reading");
409 written += size;
410 }
411 free (buf);
412
413 cpp_prepare_state (pfile, &smd);
414
415 gt_pch_restore (f);
416
417 if (cpp_read_state (pfile, name, f, smd) != 0)
418 return;
419
420 fclose (f);
421 }

Notice that here fd refers to the already opened validate PCH file, by fdopen at line 385 above, we will continue the reading at postion following target_data in the file. At that positon it should contains c_pch_header which only contains a field asm_size, and it indicates the size of the assemble code of the PCH file. It is written into asm_out_file.
If PCH file only contents assemble code, what is difference between it and library? And how can we use the data structures and functions defined in it? Thus, after the part of assemble code, PCH file also includes the content in form of intermediate tree, after reading in this part and merging into the tree of current compilation unit, PCH file acts exactly as normal header.

589 void
590 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data) in cpppch.c
591 {
592 struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
593
594 d->macros = NULL;
595 d->count = ARRAY_SIZE (d->macros->macs);
596 cpp_forall_identifiers (r, save_macros, d);
597 d->saved_pragmas = _cpp_save_pragma_names (r);
598 *data = d;
599 }

In cpp_reader, it contains field hash_table which is first initialized in _cpp_init_hashtable. In preprocessing stage, it works as hashtable for visible macros in the file. The instance of cpp_reader always stands for current handling file; now as we are handling PCH header file, we need to update the cpp_reader instance, first it needs save the macros seen so far for current file.

546 struct save_macro_item { in cpppch.c
547 struct save_macro_item *next;
548 struct cpp_hashnode macs[64];
549 };

551 struct save_macro_data
552 {
553 struct save_macro_item *macros;
554 size_t count;
555 char **saved_pragmas;
556 };

Note line 595 in cpp_prepare_state, count is 64 for new created buffer.

112 void
113 cpp_forall_identifiers (cpp_reader *pfile, cpp_cb cb, void *v) in cpppch.c
114 {
115 /* We don't need a proxy since the hash table's identifier comes
116 first in cpp_hashnode. */
117 ht_forall (pfile->hash_table, (ht_cb) cb, v);
118 }

209 void
210 ht_forall (hash_table *table, ht_cb cb, const void *v) in hashtable.c
211 {
212 hashnode *p, *limit;
213
214 p = table->entries;
215 limit = p + table->nslots;
216 do
217 if (*p)
218 {
219 if ((*cb) (table->pfile, *p, v) == 0)
220 break;
221 }
222 while (++p < limit);
223 }

Below HT_STR and HT_LEN just access str and len field of ht_identifier of cpp_hashnode. Remember that ht_identifier is the major body of cpp_hashnode and the regular node in hashtable.

561 static int in cpppch.c
562 save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
563 {
564 struct save_macro_data *data = (struct save_macro_data *)data_p;
565 if (h->type != NT_VOID
566 && (h->flags & NODE_BUILTIN) == 0)
567 {
568 cpp_hashnode *save;
569 if (data->count == ARRAY_SIZE (data->macros->macs))
570 {
571 struct save_macro_item *d = data->macros;
572 data->macros = xmalloc (sizeof (struct save_macro_item));
573 data->macros->next = d;
574 data->count = 0;
575 }
576 save = data->macros->macs + data->count;
577 data->count++;
578 memcpy (save, h, sizeof (struct cpp_hashnode));
579 HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
580 HT_LEN (HT_NODE (save)),
581 HT_LEN (HT_NODE (save)) + 1);
582 }
583 return 1;
584 }
4.1.3.1.2.1.1. #pragma directive in peprocessing
Following paragraphs are extracted from [6] about #pargma directive

The #pragma directive is the method specified by the C standard for providing additional information to the compiler, beyond what is conveyed in the language itself. Three forms of this directive (commonly known as pragmas) are specified by the 1999 C standard. A C compiler is free to attach any meaning it likes to other pragmas. GCC has historically preferred to use extension to the syntax of the language, such as __attribute__, for this purpose. However, GCC does define a few pragmas of its own. These mostly have effects on the entire translation unit or souce file. In GCC version 3, all GNU-defined, supported pragmas have been gvien a GCC prefix. This is in line with the STDC prefix on all pragmas defined by C9. For backward compatibility, pragmas which were recoginzed by previous versions are still recognized without the GCC prefix, but that usage is deprecated. Some older pragmas are deprecated in their entirety. They are not recognized with the GCC prefix. C99 introduces the _Pragma operator. This feature addresses a major problem with #pragma: being a directive, it cannot be produced as the result of macro expansion. Its syntax is _Pragma (string-literal), where string-literal can be either a normal or wide character string literal. It is destringized, by replacing all ‘//’ with a single ‘/’ and all ‘/”’ with a ‘”’. The result is then processed as if it had appeared as the right hand side of a #pragma directive. For example, _Pragma (“GCC dependency /”parse.y/””) Has the same effect as #pragma GCC dependency “parse.y”. The same effect could be achieved using macros, for example #define DO_PRAGMA(x) _Pragma (#x) DO_PRAGMA (GCC dependency “parse.y”) The standard is unclear on where a _pragma operator can appear. The preprocessor does not accept it within a preprocessing conditional directive like #if. To be safe, you are probably best keeping it out of directives other than #define, and putting it on a line of its own. The pragmas are meaningful to the preprocessor are: #pragma GCC dependency #pragma GCC dependency allows you to check the relative dates of the current file and another file. If the other file is more recent than the current file, a warning is issued. This is useful if the current file is derived from the other file, and should be regenerated. The other file is searched for using the normal include search path. Optional trailing text can be used to give more information in the warning message. #pragma GCC dependency “parse.y” #pramga GCC dependency “/usr/include/time.h” rerun fuxincludes #pragma GCC poison Sometimes, there is an identifier that you want to remove completely from your program, and make sure that is never creeps back in. To enforce this, you can poison the identifier with this pragma. #pragma GCC poison is followed by a list of identifiers to poison. If any of those identifiers appears anywhere in the source after the directive, it is a hard error. For exmaple, #pragma GCC poison printf sprintf fprintf sprintf (some_string, “hello”); Will produce an error. If a poisoned identifier appears as part of the expansion of a macro which was defined before the identifier was poisoned, it will not cause an error. This lets you poison an identifier without worrying about system headers defining macros that use it. For example, #define strrchr rindex #pragma GCC poison rindex strrchr (someth_string, ‘h’); will not produce an error. #pragma GCC system_header This pragma takes no arguments. It causes the rest of the code in the current file to be treated as if it came from as system header.

1095 char **
1096 _cpp_save_pragma_names (cpp_reader *pfile) in cpplib.c
1097 {
1098 int ct = count_registered_pragmas (pfile->pragmas);
1099 char **result = xnewvec (char *, ct);
1100 (void) save_registered_pragmas (pfile->pragmas, result);
1101 return result;
1102 }

1062 static int
1063 count_registered_pragmas (struct pragma_entry *pe) in cpplib.c
1064 {
1065 int ct = 0;
1066 for (; pe != NULL; pe = pe->next)
1067 {
1068 if (pe->is_nspace)
1069 ct += count_registered_pragmas (pe->u.space);
1070 ct++;
1071 }
1072 return ct;
1073 }

1078 static char **
1079 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1080 {
1081 for (; pe != NULL; pe = pe->next)
1082 {
1083 if (pe->is_nspace)
1084 sd = save_registered_pragmas (pe->u.space, sd);
1085 *sd++ = xmemdup (HT_STR (&pe->pragma->ident),
1086 HT_LEN (&pe->pragma->ident),
1087 HT_LEN (&pe->pragma->ident) + 1);
1088 }
1089 return sd;
1090 }

In above examples, GCC forms the space part in pe->u.space at line 1069, within which there are dependency, poison and system_header. save_registered_paragmas, co-operated with count_registered_pragmas, saves this pragmas tree into the chain constructed with objects of save_macro_data.