[NaClDocs] Add note about errno in PNaCl ABI.

native_client_sdk/src/doc/reference/pnacl-bitcode-abi.rst

 ==============================
 PNaCl Bitcode Reference Manual
 ==============================
 
 .. contents::
    :local:
    :backlinks: none
    :depth: 3
 
 Introduction
@@ skipping 247 matching lines @@
 Other kinds of LLVM metadata are not supported.
 
 Intrinsic Global Variables
 ==========================
 
 `LLVM LangRef: Intrinsic Global Variables
 <http://llvm.org/releases/3.3/docs/LangRef.html#intrinsic-global-variables>`_
 
 PNaCl bitcode does not support intrinsic global variables.
 
+.. _ir_and_errno:
+
+Errno and errors in arithmetic instructions
+===========================================
+
+Some arithmetic instructions and intrinsics have the similar semantics to
+libc math functions, but differ in the treatment of ``errno``. While the
+libc functions may set ``errno`` for domain errors, the instructions and
+intrinsics do not. This is because the variable ``errno`` is not special
+and is not required to be part of the program.
+
 Instruction Reference
 =====================
 
 List of allowed instructions
 ----------------------------
 
 This is a list of LLVM instructions supported by PNaCl bitcode. Where
 applicable, PNaCl-specific restrictions are provided.
 
 .. TODO: explain instructions or link in the future
@@ skipping 20 matching lines @@
   guaranteed to trap in PNaCl bitcode.
 
 * ``and``
 * ``or``
 * ``xor``
 * ``fadd``
 * ``fsub``
 * ``fmul``
 * ``fdiv``
 * ``frem``
+
+  The frem instruction has the semantics of the libc fmod function for
+  computing the floating point remainder. If the numerator is infinity, or
+  denominator is zero, or either are NaN, then the result is NaN.
+  Unlike the libc fmod function, this does not set ``errno`` when the
+  result is NaN (see the :ref:`instructions and errno <ir_and_errno>`
+  section).
+
 * ``alloca``
 
   See :ref:`alloca instructions <bitcode_allocainst>`.
 
 * ``load``, ``store``
 
   The pointer argument of these instructions must be a *normalized* pointer (see
   :ref:`pointer types <bitcode_pointertypes>`). The ``volatile`` and ``atomic``
   attributes are not supported. Loads and stores of the type ``i1`` are not
   supported.
@@ skipping 71 matching lines @@
 * ``llvm.cttz``
 * ``llvm.ctpop``
 
   The overloaded llvm.ctlz, llvm.cttz, and llvm.ctpop intrinsics are only
   supported with the i32 and i64 argument types (the types supported by
   C-style GCC builtins).
 
 * ``llvm.sqrt``
 
   The overloaded ``llvm.sqrt`` intrinsic is only supported for float
-  and double arguments types. Unlike the standard LLVM intrinsic,
-  PNaCl guarantees that llvm.sqrt returns a QNaN for values less than -0.0.
+  and double arguments types. This has the same semantics as the libc
+  sqrt function, returning NaN for values less than -0.0. However, this
+  does not set ``errno`` when the result is NaN (see the
+  :ref:`instructions and errno <ir_and_errno>` section).
 
 * ``llvm.stacksave``
 * ``llvm.stackrestore``
 
   These intrinsics are used to implement language features like scoped automatic
   variable sized arrays in C99. ``llvm.stacksave`` returns a value that
   represents the current state of the stack. This value may only be used as the
   argument to ``llvm.stackrestore``, which restores the stack to the given
   state.
 
@@ skipping 113 matching lines @@
 
     declare i1 @llvm.nacl.atomic.is.lock.free(i32 <byte_size>, i8* <address>)
 
 The ``llvm.nacl.atomic.is.lock.free`` intrinsic is designed to
 determine at translation time whether atomic operations of a certain
 ``byte_size`` (a compile-time constant), at a particular ``address``,
 are lock-free or not. This reflects the C11 ``atomic_is_lock_free``
 function from header ``<stdatomic.h>`` and the C++11 ``is_lock_free``
 member function in header ``<atomic>``. It can be used through the
 ``__nacl_atomic_is_lock_free`` builtin.