[GN]: Support for loadable modules

tools/gn/docs/language.md

 # GN Language and Operation
 
 [TOC]
 
 ## Introduction
 
 This page describes many of the language details and behaviors.
 
 ### Use the built-in help!
 
@@ skipping 75 matching lines @@
 
 There is no way to get the length of a list. If you find yourself
 wanting to do this kind of thing, you're trying to do too much work in
 the build.
 
 Lists support appending:
 
 ```
 a = [ "first" ]
 a += [ "second" ]  # [ "first", "second" ]
-a += [ "third", "fourth" ]  # [ "first", "second", "third", "fourth" ] 
-b = a + [ "fifth" ]  # [ "first", "second", "third", "fourth", "fifth" ] 
+a += [ "third", "fourth" ]  # [ "first", "second", "third", "fourth" ]
+b = a + [ "fifth" ]  # [ "first", "second", "third", "fourth", "fifth" ]
 ```
 
 Appending a list to another list appends the items in the second list
 rather than appending the list as a nested member.
 
 You can remove items from a list:
 
 ```
 a = [ "first", "second", "third", "first" ]
 b = a - [ "first" ]  # [ "second", "third" ]
@@ skipping 45 matching lines @@
 
 Conditionals look like C:
 
 ```
   if (is_linux || (is_win && target_cpu == "x86")) {
     sources -= [ "something.cc" ]
   } else if (...) {
     ...
   } else {
     ...
-  }  
+  }
 ```
 
 You can use them in most places, even around entire targets if the
 target should only be declared in certain circumstances.
 
 ### Functions
 
 Simple functions look like most other languages:
 
 ```
@@ skipping 195 matching lines @@
 other targets. The built-in target types (see `gn help <targettype>` for
 more help) are:
 
   * `action`: Run a script to generate a file.
   * `action_foreach`: Run a script once for each source file.
   * `component`: Configurable to be another type of library.
   * `executable`: Generates an executable file.
   * `group`: A virtual dependency node that refers to one or more other
     targets.
   * `shared_library`: A .dll or .so.
+  * `loadable_module`: A .dll or .so loadable only at runtime.
   * `source_set`: A lightweight virtual static library (usually
     preferrable over a real static library since it will build faster).
   * `static_library`: A .lib or .a file (normally you'll want a
-    source\_set instead).
+    `source_set` instead).
 
 You can extend this to make custom target types using templates (see below).
 
 ## Configs
 
 Configs are named objects that specify sets of flags, include
 directories, and defines. They can be applied to a target and pushed to
 dependent targets.
 
 To define a config:
@@ skipping 332 matching lines @@
 settings which work a bit differently in Blaze. This is partially to
 make conversion from the existing GYP code easier, and the GYP
 constructs generally offer more fine-grained control (which is either
 good or bad, depending on the situation).
 
 GN also uses GYP names like "sources" instead of "srcs" since
 abbreviating this seems needlessly obscure, although it uses Blaze's
 "deps" since "dependencies" is so hard to type. Chromium also compiles
 multiple languages in one target so specifying the language type on the
 target name prefix was dropped (e.g. from `cc_library`).