NaCl documentation: update vector documentation

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

 ==============================
 PNaCl Bitcode Reference Manual
 ==============================
 
 .. contents::
    :local:
    :backlinks: none
    :depth: 3
 
 Introduction
@@ skipping 180 matching lines @@
 Scalar types
 ------------
 
 * The only scalar types allowed are integer, float (32-bit floating point),
   double (64-bit floating point) and void.
 
   * The only integer sizes allowed are i1, i8, i16, i32 and i64.
   * The only integer sizes allowed for function arguments and function return
     values are i32 and i64.
 
+Vector types
+------------
+
+The only vector types allowed are 128-bit vectors integers of elements
+size i8, i16, i32, and float. Vectors of i1 type are allowed with
+element counts corresponding to the allowed element counts listed
+previously (their width is therefore not 128-bits).

[Karl, 2014/05/05 19:49:40]

Isn't this last sentence a contraction of the first?

[JF, 2014/05/05 23:12:49]

Updated to be clearer.

+
 Array and struct types
 ----------------------
 
 Array and struct types are only allowed in
 :ref:`global variable initializers <bitcode_globalvariables>`.
 
 .. _bitcode_pointertypes:
 
 Pointer types
 -------------
@@ skipping 151 matching lines @@
 
   The pointer argument of a ``bitcast`` instruction must be a *inherent* pointer
   (see :ref:`pointer types <bitcode_pointertypes>`).
 
 * ``icmp``
 * ``fcmp``
 * ``phi``
 * ``select``
 * ``call``
 * ``unreachable``
+* ``insertelement``
+* ``extractelement``
 
 .. _bitcode_allocainst:
 
 ``alloca``
 ----------
 
 The only allowed type for ``alloca`` instructions in PNaCl bitcode is i8. The
 size argument must be an i32. For example:
 
 .. naclcode::
@@ skipping 164 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.