[docs] Fix self-contradictory description of llvm_unreachable

[jkorous]

Summary

Just two paragraphs above it says:

If the compiler does not support this [skipping code generation for a particular branch], it will fall back to the "abort" implementation.

And that actually correctly describes current llvm_unreachable implementation.
https://llvm.org/docs/CodingStandards.html#assert-liberally

Alternatively, if we agree that llvm_unreachable should really have an assert-like semantics then we can make the call to abort in llvm_unreachable_internal conditional on #ifndef NDEBUG.
https://github.com/llvm/llvm-project/blob/master/llvm/lib/Support/ErrorHandling.cpp#L210
That would've to be approved by more people though.

[aaron.ballman]

LGTM! Thank you for these fixes; the changes do a good job of describing the current behavior of the APIs. If you'd like to propose a behavioral change, I agree that should be done with an RFC to the community.

llvm/docs/CodingStandards.rst

 
 Use ``llvm_unreachable`` to mark a specific point in code that should never be
 reached. This is especially desirable for addressing warnings about unreachable
 branches, etc., but can be used whenever reaching a particular code path is
 unconditionally a bug (not originating from user input; see below) of some kind.
 Use of ``assert`` should always include a testable predicate (as opposed to
 ``assert(false)``).
 
-Neither assertions or ``llvm_unreachable`` will abort the program on a release
-build. If the error condition can be triggered by user input then the
+If the error condition can be triggered by user input then the
 recoverable error mechanism described in :doc:`ProgrammersManual` should be
 used instead. In cases where this is not practical, ``report_fatal_error`` may
 be used.
 
 Another issue is that values used only by assertions will produce an "unused
 value" warning when assertions are disabled.  For example, this code will warn:
 
 .. code-block:: c++

llvm/include/llvm/Support/ErrorHandling.h

 llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 }
 
 /// Marks that the current location is not supposed to be reachable.
 /// In !NDEBUG builds, prints the message and location info to stderr.
 /// In NDEBUG builds, becomes an optimizer hint that the current location
 /// is not supposed to be reachable.  On compilers that don't support
-/// such hints, prints a reduced message instead.
+/// such hints, prints a reduced message instead and aborts the program.
 ///
 /// Use this instead of assert(0).  It conveys intent more clearly and
 /// allows compilers to omit some unnecessary code.
 #ifndef NDEBUG
 #define llvm_unreachable(msg) \
   ::llvm::llvm_unreachable_internal(msg, __FILE__, __LINE__)
 #elif defined(LLVM_BUILTIN_UNREACHABLE)
 #define llvm_unreachable(msg) LLVM_BUILTIN_UNREACHABLE
 #else
 #define llvm_unreachable(msg) ::llvm::llvm_unreachable_internal()
 #endif
 
 #endif