Add arflags to GN

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 2985 matching lines @@
 
     {{source_gen_dir}}
     {{source_out_dir}}
         The directory in the generated file and output directories,
         respectively, for the current input file. If the source file
         is in the same directory as the target is declared in, they will
         will be the same as the "target" versions above.
         Example: "gen/base/test"
 
   Linker tools have multiple inputs and (potentially) multiple outputs
+  The static library tool ("alink") is not considered a linker tool.
   The following expansions are available:
 
     {{inputs}}
     {{inputs_newline}}
         Expands to the inputs to the link step. This will be a list of
         object files and static libraries.
         Example: "obj/foo.o obj/bar.o obj/somelibrary.a"
 
         The "_newline" version will separate the input files with
         newlines instead of spaces. This is useful in response files:
@@ skipping 39 matching lines @@
 
     {{solibs}}
         Extra libraries from shared library dependencide not specified
         in the {{inputs}}. This is the list of link_output files from
         shared libraries (if the solink tool specifies a "link_output"
         variable separate from the "depend_output").
 
         These should generally be treated the same as libs by your tool.
         Example: "libfoo.so libbar.so"
 
+  The static library ("alink") tool allows {{arflags}} plus the common
+  tool substitutions.
+
   The copy tool allows the common compiler/linker substitutions, plus
   {{source}} which is the source of the copy. The stamp tool allows
   only the common tool substitutions.
 
   The copy_bundle_data and compile_xcassets tools only allows the common
   tool substitutions. Both tools are required to create iOS/OS X bundles
   and need only be defined on those platforms.
 
   The copy_bundle_data tool will be called with one source and needs to
   copy (optionally optimizing the data representation) to its output. It
@@ skipping 643 matching lines @@
     # Sources here can include headers from a despite lack of deps.
     ...
   }
 
   group("a_b_shared_deps") {
     public_deps = [ ":c" ]
   }
 
 
 ```
+## **arflags**: Arguments passed to static_library archiver.
+
+```
+  A list of flags passed to the archive/lib command that creates static
+  libraries.
+
+  arflags are NOT pushed to dependents, so applying arflags to source
+  sets or any other target type will be a no-op. As with ldflags,
+  you could put the arflags in a config and set that as a public or
+  "all dependent" config, but that will likely not be what you want.
+  If you have a chain of static libraries dependent on each other,
+  this can cause the flags to propagate up to other static libraries.
+  Due to the nature of how arflags are typically used, you will normally
+  want to apply them directly on static_library targets themselves.
+
+```
+
+### **Ordering of flags and values**
+
+```
+  1. Those set on the current target (not in a config).
+  2. Those set on the "configs" on the target in order that the
+     configs appear in the list.
+  3. Those set on the "all_dependent_configs" on the target in order
+     that the configs appear in the list.
+  4. Those set on the "public_configs" on the target in order that
+     those configs appear in the list.
+  5. all_dependent_configs pulled from dependencies, in the order of
+     the "deps" list. This is done recursively. If a config appears
+     more than once, only the first occurance will be used.
+  6. public_configs pulled from dependencies, in the order of the
+     "deps" list. If a dependency is public, they will be applied
+     recursively.
+
+
+```
 ## **args**: Arguments passed to an action.
 
 ```
   For action and action_foreach targets, args is the list of arguments
   to pass to the script. Typically you would use source expansion (see
   "gn help source_expansion") to insert the source file names.
 
   See also "gn help action" and "gn help action_foreach".
 
 
@@ skipping 2152 matching lines @@
 **  -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.
 **  \--threads**: Specify number of worker threads.
 **  \--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.
 
 ```