Update docs

Author: gbMattN

clang/docs/TypeSanitizer.rst

@@ -24,10 +24,6 @@ Typical memory overhead introduced by TypeSanitizer is about **8x**. Runtime slo
 depending on how often the instrumented code relies on type aliasing. In the best case slowdown is
 **2x-3x**.
 
-The compiler instrumentation also has an impact on code size and compilation overhead. There is an
-experimental :ref:`instrumentation outlining option<outlining_flag>` which can greatly reduce this
-but this may decrease runtime performance.
-
 The TypeSanitizer Algorithm
 ===========================
 For each TBAA type-access descriptor, encoded in LLVM IR using TBAA Metadata, the instrumentation 
@@ -132,22 +128,13 @@ references to LLVM IR specific terms.
 Sanitizer features
 ==================
 
-.. _outlining_flag:
-
 Instrumentation code outlining
 ------------------------------
 
-By default TypeSanitizer inlines the instrumentation code. This leads to increased
-binary size and compilation time. Using the clang flag
-``-fsanitize-type-outline-instrumentation`` (default: ``false``)
-forces all code instrumentation to be outlined. This reduces the size of the
-generated code and reduces compile-time overhead, but it also reduces runtime
-performance.
-
-This outlined instrumentation is new. If you wish to verify that the outlined instrumentation
-is behaving in the same way as the inline instrumentation, you can force TypeSanitizer
-to use both types of instrumentation. You can use the clang flag
-``-fsanitize-type-verify-outlined-instrumentation`` (default: ``false``) to do this.
+By default TypeSanitizer inserts instrumentation through function calls. This may lead to a reduction in
+runtime performance. ``-fno-sanitize-type-outline-instrumentation`` (default: ``false``) forces all
+code instrumentation to be inlined. This will increase the size of the generated code and compiler
+overhead, but may improve the runtime performance of the resulting code.
 
 ``__has_feature(type_sanitizer)``
 ------------------------------------
@@ -200,10 +187,6 @@ Limitations
   shadow memory for each byte of user memory.
 * There are transformation passes which run before TypeSanitizer. If these 
   passes optimize out an aliasing violation, TypeSanitizer cannot catch it.
-* Currently, all instrumentation is inlined. This can result in a **15x** 
-  (on average) increase in generated file size, and **3x** to **7x** increase 
-  in compile time. In some documented cases this can cause the compiler to hang.
-  There are plans to improve this in the future.
 * Codebases that use unions and struct-initialized variables can see incorrect 
   results, as TypeSanitizer doesn't yet instrument these reliably.
 * Since Clang & LLVM's TBAA system is used to generate the checks used by the