Add a //nogncheck anntation to GN include checker

tools/gn/docs/reference.md

 # GN Reference
 
 *This page is automatically generated from* `gn help --markdown all`.
 
 ## **--args**: Specifies build arguments overrides.
 
 ```
   See "gn help buildargs" for an overview of how build arguments work.
 
   Most operations take a build directory. The build arguments are taken
@@ skipping 993 matching lines @@
       tree in the order that the targets appear in "deps".
    4. All dependent configs from a breadth-first traversal of the
       dependency tree in the order that the targets appear in "deps".
 
 ```
 
 ### **Variables valid in a config definition**:
 ```
   Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,
          defines, include_dirs, ldflags, lib_dirs, libs
+         precompiled_header, precompiled_source
 
 ```
 
 ### **Variables on a target used to apply configs**:
 ```
   all_dependent_configs, configs, public_configs,
   forward_dependent_configs_from
 
 ```
 
@@ skipping 178 matching lines @@
 
 
 ```
 ## **executable**: Declare an executable target.
 
 ### **Variables**
 
 ```
   Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,
          defines, include_dirs, ldflags, lib_dirs, libs
+         precompiled_header, precompiled_source
   Deps: data_deps, deps, forward_dependent_configs_from, public_deps
   Dependent configs: all_dependent_configs, public_configs
   General: check_includes, configs, data, inputs, output_name,
            output_extension, public, sources, testonly, visibility
 
 
 ```
 ## **foreach**: Iterate over a list.
 
 ```
@@ skipping 691 matching lines @@
   (say you dynamically load the library at runtime), then you should
   depend on the shared library via "data_deps" instead.
 
 ```
 
 ### **Variables**
 
 ```
   Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,
          defines, include_dirs, ldflags, lib_dirs, libs
+         precompiled_header, precompiled_source
   Deps: data_deps, deps, forward_dependent_configs_from, public_deps
   Dependent configs: all_dependent_configs, public_configs
   General: check_includes, configs, data, inputs, output_name,
            output_extension, public, sources, testonly, visibility
 
 
 ```
 ## **source_set**: Declare a source set target.
 
 ```
@@ skipping 20 matching lines @@
   no way to express this concept when linking multiple static libraries
   into a shared library.
 
 ```
 
 ### **Variables**
 
 ```
   Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,
          defines, include_dirs, ldflags, lib_dirs, libs
+         precompiled_header, precompiled_source
   Deps: data_deps, deps, forward_dependent_configs_from, public_deps
   Dependent configs: all_dependent_configs, public_configs
   General: check_includes, configs, data, inputs, output_name,
            output_extension, public, sources, testonly, visibility
 
 
 ```
 ## **static_library**: Declare a static library target.
 
 ```
   Make a ".a" / ".lib" file.
 
   If you only need the static library for intermediate results in the
   build, you should consider a source_set instead since it will skip
   the (potentially slow) step of creating the intermediate library file.
 
 ```
 
 ### **Variables**
 
 ```
   Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,
          defines, include_dirs, ldflags, lib_dirs, libs
+         precompiled_header, precompiled_source
   Deps: data_deps, deps, forward_dependent_configs_from, public_deps
   Dependent configs: all_dependent_configs, public_configs
   General: check_includes, configs, data, inputs, output_name,
            output_extension, public, sources, testonly, visibility
 
 
 ```
 ## **template**: Define a template rule.
 
 ```
@@ skipping 289 matching lines @@
         Prefix to use for the output name. Defaults to empty. This
         prefix will be prepended to the name of the target (or the
         output_name if one is manually specified for it) if the prefix
         is not already there. The result will show up in the
         {{output_name}} substitution pattern.
 
         This is typically used to prepend "lib" to libraries on
         Posix systems:
           output_prefix = "lib"
 
+    precompiled_header_type  [string]
+        Valid for: "cc", "cxx", "objc", "objcxx"
+
+        Type of precompiled headers. If undefined or the empty string,
+        precompiled headers will not be used for this tool. Otherwise
+        use "msvc" which is the only currently supported value.
+
+        For precompiled headers to be used for a given target, the
+        target (or a config applied to it) must also specify a
+        "precompiled_header" and, for "msvc"-style headers, a
+        "precompiled_source" value.
+
+        See "gn help precompiled_header" for more.
+
     restat  [boolean]
         Valid for: all tools (optional, defaults to false)
 
         Requests that Ninja check the file timestamp after this tool has
         run to determine if anything changed. Set this if your tool has
         the ability to skip writing output if the output file has not
         changed.
 
         Normally, Ninja will assume that when a tool runs the output
         be new and downstream dependents must be rebuild. When this is
@@ skipping 20 matching lines @@
         but passes the linker flags directly on the command line:
           tool("link") {
             command = "link -o {{output}} {{ldflags}} @{{output}}.rsp"
             rspfile = "{{output}}.rsp"
             rspfile_content = "{{inputs}} {{solibs}} {{libs}}"
           }
 
 ```
 
 ### **Expansions for tool variables**
+
 ```
   All paths are relative to the root build directory, which is the
   current directory for running all tools. These expansions are
   available to all tools:
 
     {{label}}
         The label of the current target. This is typically used in the
         "description" field for link tools. The toolchain will be
         omitted from the label for targets in the default toolchain, and
         will be included for targets in other toolchains.
@@ skipping 890 matching lines @@
   When true (the default), the "gn check" command (as well as
   "gn gen" with the --check flag) will check this target's sources
   and headers for proper dependencies.
 
   When false, the files in this target will be skipped by default.
   This does not affect other targets that depend on the current target,
   it just skips checking the includes of the current target's files.
 
 ```
 
+### **Controlling includes individually**
+
+```
+  If only certain includes are problematic, you can annotate them
+  individually rather than disabling header checking on an entire
+  target. Add the string "nogncheck" to the include line:
+
+    #include "foo/something_weird.h"  // nogncheck (bug 12345)
+
+  It is good form to include a reference to a bug (if the include is
+  improper, or some other comment expressing why the header checker
+  doesn't work for this particular case.
+
+  The most common reason to need "nogncheck" is conditional includes.
+  The header checker does not understand the preprocessor, so may flag
+  some includes as improper even if the dependencies and #defines are
+  always matched correctly:
+
+    #if defined(ENABLE_DOOM_MELON)
+    #include "doom_melon/beam_controller.h"  // nogncheck
+    #endif
+
+```
+
 ### **Example**
 
 ```
   source_set("busted_includes") {
     # This target's includes are messed up, exclude it from checking.
     check_includes = false
     ...
   }
 
 
@@ skipping 510 matching lines @@
   target types and indicates the resulting files. The values may contain
   source expansions to generate the output names from the sources (see
   "gn help source_expansion").
 
   For copy targets, the outputs is the destination for the copied
   file(s). For actions, the outputs should be the list of files
   generated by the script.
 
 
 ```
+## **precompiled_header**: [string] Header file to precompile.
+
+```
+  Precompiled headers will be used when a target specifies this
+  value, or a config applying to this target specifies this value.
+  In addition, the tool corresponding to the source files must also
+  specify precompiled headers (see "gn help tool"). The tool
+  will also specify what type of precompiled headers to use.
+
+  The precompiled header/source variables can be specified on a target
+  or a config, but must be the same for all configs applying to a given
+  target since a target can only have one precompiled header.
+
+```
+
+### **MSVC precompiled headers**
+
+```
+  When using MSVC-style precompiled headers, the "precompiled_header"
+  value is a string corresponding to the header. This is NOT a path
+  to a file that GN recognises, but rather the exact string that appears
+  in quotes after an #include line in source code. The compiler will
+  match this string against includes or forced includes (/FI).
+
+  MSVC also requires a source file to compile the header with. This must
+  be specified by the "precompiled_source" value. In contrast to the
+  header value, this IS a GN-style file name, and tells GN which source
+  file to compile to make the .pch file used for subsequent compiles.
+
+  If you use both C and C++ sources, the precompiled header and source
+  file will be compiled using both tools. You will want to make sure
+  to wrap C++ includes in __cplusplus #ifdefs so the file will compile
+  in C mode.
+
+  For example, if the toolchain specifies MSVC headers:
+
+    toolchain("vc_x64") {
+      ...
+      tool("cxx") {
+        precompiled_header_type = "msvc"
+        ...
+
+  You might make a config like this:
+
+    config("use_precompiled_headers") {
+      precompiled_header = "build/precompile.h"
+      precompiled_source = "//build/precompile.cc"
+
+      # Either your source files should #include "build/precompile.h"
+      # first, or you can do this to force-include the header.
+      cflags = [ "/FI$precompiled_header" ]
+    }
+
+  And then define a target that uses the config:
+
+    executable("doom_melon") {
+      configs += [ ":use_precompiled_headers" ]
+      ...
+
+
+
+```
+## **precompiled_source**: [file name] Source file to precompile.
+
+```
+  The source file that goes along with the precompiled_header when
+  using "msvc"-style precompiled headers. It will be implicitly added
+  to the sources of the target. See "gn help precompiled_header".
+
+
+```
 ## **public**: Declare public header files for a target.
 
 ```
   A list of files that other targets can include. These permissions are
   checked via the "check" command (see "gn help check").
 
   If no public files are declared, other targets (assuming they have
   visibility to depend on this target can include any file in the
   sources list. If this variable is defined on a target, dependent
   targets may only include files on this whitelist.
@@ skipping 771 matching lines @@
 **  --nocolor**: Force non-colored output.
 **  -q**: Quiet mode. Don't print output on success.
 **  --root**: Explicitly specify source root.
 **  --runtime-deps-list-file**: Save runtime dependencies for targets in file.
 **  --time**: Outputs a summary of how long everything took.
 **  --tracelog**: Writes a Chrome-compatible trace log to the given file.
 **  -v**: Verbose logging.
 **  --version**: Prints the GN version number and exits.
 
 ```