PNaCl documentation: update the bitcode reference manual for vector load/store

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

 ==============================
 PNaCl Bitcode Reference Manual
 ==============================
 
 .. contents::
    :local:
    :backlinks: none
    :depth: 3
 
 Introduction
@@ skipping 204 matching lines @@
 Array and struct types are only allowed in
 :ref:`global variable initializers <bitcode_globalvariables>`.
 
 .. _bitcode_pointertypes:
 
 Pointer types
 -------------
 
 Only the following pointer types are allowed:
 
-* Pointers to valid PNaCl bitcode scalar types, as specified above.
+* Pointers to valid PNaCl bitcode scalar types, as specified above, except for
+  ``i1``.
+* Pointers to valid PNaCl bitcode vector types, as specified above, except for
+  ``<? x i1>``.
 * Pointers to functions.
 
 In addition, the address space for all pointers must be 0.
 
 A pointer is *inherent* when it represents the return value of an ``alloca``
 instruction, or is an address of a global value.
 
 A pointer is *normalized* if it's either:
 
 * *inherent*
@@ skipping 100 matching lines @@
   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.
+  attributes are not supported. Loads and stores of the type ``i1`` and ``<? x
+  i1>`` are not supported.
 
-  These instructions must use ``align 1`` on integer memory accesses, ``align 4``
-  for ``float`` accesses and ``align 8`` for ``double`` accesses.
+  These instructions must follow the following alignment restrictions:
+
+  * On integer memory accesses: ``align 1``.
+  * On ``float`` memory accesses: ``align 1`` or ``align 4``.
+  * On ``double`` memory accesses: ``align 1`` or ``align 8``.
+  * On vector memory accesses: alignment at the vector's element width, for
+    example ``<4 x i32>`` must be ``align 4``.
 
 * ``trunc``
 * ``zext``
 * ``sext``
 * ``fptrunc``
 * ``fpext``
 * ``fptoui``
 * ``fptosi``
 * ``uitofp``
 * ``sitofp``
@@ skipping 198 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.