Update docs.

The ``#pragma clang loop`` directive is used to specify hints for optimizing the

subsequent for, while, do-while, or c++11 range-based for loop. The directive

provides options for vectorization, interleaving, and unrolling. Loop hints can

be specified before any loop and will be ignored if the optimization is not safe

to apply.

Vectorization and Interleaving

------------------------------

provides options for vectorization and interleaving. Loop hints can be specified

before any loop and will be ignored if the optimization is not safe to apply.

A vectorized loop performs multiple iterations of the original loop

in parallel using vector instructions. The instruction set of the target

Specifying a width/count of 1 disables the optimization, and is equivalent to

``vectorize(disable)`` or ``interleave(disable)``.

Loop Unrolling

--------------

Unrolling a loop reduces the loop control overhead and exposes more

opportunities for ILP. Loops can be fully or partially unrolled. Full unrolling

eliminates the loop and replaces it with an enumerated sequence of loop

iterations. Full unrolling is only possible if the loop trip count is known at

compile time. Partial unrolling replicates the loop body within the loop and

reduces the trip count.

If ``unroll(enable)`` is specified the unroller will attempt to fully unroll the

loop if the trip count is known at compile time. If the loop count is not known

or the fully unrolled code size is greater than the limit specified by the

`-pragma-unroll-threshold` command line option the loop will be partially

unrolled subject to the same limit.

.. code-block:: c++

  #pragma clang loop unroll(enable)

  for(...) {

    ...

  }

The unroll count can be specified explicitly with ``unroll_count(_value_)`` where

_value_ is a positive integer. If this value is greater than the trip count the

loop will be fully unrolled. Otherwise the loop is partially unrolled subject

to the `-pragma-unroll-threshold` limit.

.. code-block:: c++

  #pragma clang loop unroll_count(8)

  for(...) {

    ...

  }

Unrolling of a loop can be prevented by specifying ``unroll(disable)``.

Additional Information

----------------------

For convenience multiple loop hints can be specified on a single line.

.. code-block:: c++

-----------------------

Loop optimization hints can be specified using the new `#pragma clang loop`

directive just prior to the desired loop. The directive allows vectorization,

interleaving, and unrolling to be enabled or disabled. Vector width as well

as interleave and unrolling count can be manually specified.  See

:ref:`langext-pragma-loop` for details.

Clang now supports the `#pragma unroll` directive to specify loop unrolling

optimization hints.  Placed just prior to the desired loop, `#pragma unroll`

directs the loop unroller to attempt to fully unroll the loop.  The pragma may

also be specified with a positive integer parameter indicating the desired

unroll count: `#pragma unroll _value_`.  The unroll count parameter can be

optionally enclosed in parentheses.

directive just prior to the desired loop. The directive allows vectorization and

interleaving to be enabled or disabled. Vector width as well as interleave count

can be manually specified.  See :ref:`langext-pragma-loop` for details.

C Language Changes in Clang

---------------------------