<dl>
- <dt><tt><b><a name="linkage_internal">internal</a></b></tt> </dt>
+ <dt><tt><b><a name="linkage_internal">internal</a></b></tt>: </dt>
<dd>Global values with internal linkage are only directly accessible by
objects in the current module. In particular, linking code into a module with
allowed to be discarded.
</dd>
+ <dt><tt><b><a name="linkage_common">common</a></b></tt>: </dt>
+
+ <dd>"<tt>common</tt>" linkage is exactly the same as <tt>linkonce</tt>
+ linkage, except that unreferenced <tt>common</tt> globals may not be
+ discarded. This is used for globals that may be emitted in multiple
+ translation units, but that are not guaranteed to be emitted into every
+ translation unit that uses them. One example of this is tentative
+ definitions in C, such as "<tt>int X;</tt>" at global scope.
+ </dd>
+
<dt><tt><b><a name="linkage_weak">weak</a></b></tt>: </dt>
- <dd>"<tt>weak</tt>" linkage is exactly the same as <tt>linkonce</tt> linkage,
- except that unreferenced <tt>weak</tt> globals may not be discarded. This is
- used for globals that may be emitted in multiple translation units, but that
- are not guaranteed to be emitted into every translation unit that uses them.
- One example of this are common globals in C, such as "<tt>int X;</tt>" at
- global scope.
+ <dd>"<tt>weak</tt>" linkage is the same as <tt>common</tt> linkage, except
+ that some targets may choose to emit different assembly sequences for them
+ for target-dependent reasons. This is used for globals that are declared
+ "weak" in C source code.
</dd>
<dt><tt><b><a name="linkage_appending">appending</a></b></tt>: </dt>
<a href="#t_vector">vector</a>
<a href="#t_struct">structure</a>,
<a href="#t_array">array</a>,
+ <a href="#t_label">label</a>.
</td>
</tr>
<tr>
<p>The <a href="#t_firstclass">first class</a> types are perhaps the
most important. Values of these types are the only ones which can be
produced by instructions, passed as arguments, or used as operands to
-instructions. This means that all structures and arrays must be
-manipulated either by pointer or by component.</p>
+instructions.</p>
</div>
<!-- ======================================================================= -->
<p>There are several different binary operators:</p>
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_add">'<tt>add</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_add">'<tt>add</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = add <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+
+<pre>
+ <result> = add <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>add</tt>' instruction returns the sum of its two operands.</p>
+
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>add</tt>' instruction must be either <a
- href="#t_integer">integer</a> or <a href="#t_floating">floating point</a> values.
- This instruction can also take <a href="#t_vector">vector</a> versions of the values.
-Both arguments must have identical types.</p>
+
+<p>The two arguments to the '<tt>add</tt>' instruction must be <a
+ href="#t_integer">integer</a>, <a href="#t_floating">floating point</a>, or
+ <a href="#t_vector">vector</a> values. Both arguments must have identical
+ types.</p>
+
<h5>Semantics:</h5>
+
<p>The value produced is the integer or floating point sum of the two
operands.</p>
+
<p>If an integer sum has unsigned overflow, the result returned is the
mathematical result modulo 2<sup>n</sup>, where n is the bit width of
the result.</p>
+
<p>Because LLVM integers use a two's complement representation, this
instruction is appropriate for both signed and unsigned integers.</p>
+
<h5>Example:</h5>
-<pre> <result> = add i32 4, %var <i>; yields {i32}:result = 4 + %var</i>
+
+<pre>
+ <result> = add i32 4, %var <i>; yields {i32}:result = 4 + %var</i>
</pre>
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_sub">'<tt>sub</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_sub">'<tt>sub</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = sub <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+
+<pre>
+ <result> = sub <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>sub</tt>' instruction returns the difference of its two
operands.</p>
-<p>Note that the '<tt>sub</tt>' instruction is used to represent the '<tt>neg</tt>'
-instruction present in most other intermediate representations.</p>
+
+<p>Note that the '<tt>sub</tt>' instruction is used to represent the
+'<tt>neg</tt>' instruction present in most other intermediate
+representations.</p>
+
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>sub</tt>' instruction must be either <a
- href="#t_integer">integer</a> or <a href="#t_floating">floating point</a>
-values.
-This instruction can also take <a href="#t_vector">vector</a> versions of the values.
-Both arguments must have identical types.</p>
+
+<p>The two arguments to the '<tt>sub</tt>' instruction must be <a
+ href="#t_integer">integer</a>, <a href="#t_floating">floating point</a>,
+ or <a href="#t_vector">vector</a> values. Both arguments must have identical
+ types.</p>
+
<h5>Semantics:</h5>
+
<p>The value produced is the integer or floating point difference of
the two operands.</p>
+
<p>If an integer difference has unsigned overflow, the result returned is the
mathematical result modulo 2<sup>n</sup>, where n is the bit width of
the result.</p>
+
<p>Because LLVM integers use a two's complement representation, this
instruction is appropriate for both signed and unsigned integers.</p>
+
<h5>Example:</h5>
<pre>
<result> = sub i32 4, %var <i>; yields {i32}:result = 4 - %var</i>
<result> = sub i32 0, %val <i>; yields {i32}:result = -%var</i>
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_mul">'<tt>mul</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_mul">'<tt>mul</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
<pre> <result> = mul <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
<h5>Overview:</h5>
<p>The '<tt>mul</tt>' instruction returns the product of its two
operands.</p>
+
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>mul</tt>' instruction must be either <a
- href="#t_integer">integer</a> or <a href="#t_floating">floating point</a>
-values.
-This instruction can also take <a href="#t_vector">vector</a> versions of the values.
-Both arguments must have identical types.</p>
+
+<p>The two arguments to the '<tt>mul</tt>' instruction must be <a
+href="#t_integer">integer</a>, <a href="#t_floating">floating point</a>,
+or <a href="#t_vector">vector</a> values. Both arguments must have identical
+types.</p>
+
<h5>Semantics:</h5>
+
<p>The value produced is the integer or floating point product of the
two operands.</p>
+
<p>If the result of an integer multiplication has unsigned overflow,
the result returned is the mathematical result modulo
2<sup>n</sup>, where n is the bit width of the result.</p>
<pre> <result> = mul i32 4, %var <i>; yields {i32}:result = 4 * %var</i>
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"> <a name="i_udiv">'<tt>udiv</tt>' Instruction
</a></div>
<h5>Overview:</h5>
<p>The '<tt>udiv</tt>' instruction returns the quotient of its two
operands.</p>
+
<h5>Arguments:</h5>
+
<p>The two arguments to the '<tt>udiv</tt>' instruction must be
-<a href="#t_integer">integer</a> values. Both arguments must have identical
-types. This instruction can also take <a href="#t_vector">vector</a> versions
-of the values in which case the elements must be integers.</p>
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
+
<p>The value produced is the unsigned integer quotient of the two operands.</p>
<p>Note that unsigned integer division and signed integer division are distinct
operations; for signed integer division, use '<tt>sdiv</tt>'.</p>
</a> </div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> <result> = sdiv <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+<pre>
+ <result> = sdiv <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>sdiv</tt>' instruction returns the quotient of its two
operands.</p>
+
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>sdiv</tt>' instruction must be
-<a href="#t_integer">integer</a> values. Both arguments must have identical
-types. This instruction can also take <a href="#t_vector">vector</a> versions
-of the values in which case the elements must be integers.</p>
+
+<p>The two arguments to the '<tt>sdiv</tt>' instruction must be
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
<p>The value produced is the signed integer quotient of the two operands rounded towards zero.</p>
<p>Note that signed integer division and unsigned integer division are distinct
Instruction</a> </div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> <result> = fdiv <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+<pre>
+ <result> = fdiv <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
<h5>Overview:</h5>
+
<p>The '<tt>fdiv</tt>' instruction returns the quotient of its two
operands.</p>
+
<h5>Arguments:</h5>
+
<p>The two arguments to the '<tt>fdiv</tt>' instruction must be
-<a href="#t_floating">floating point</a> values. Both arguments must have
-identical types. This instruction can also take <a href="#t_vector">vector</a>
-versions of floating point values.</p>
+<a href="#t_floating">floating point</a> or <a href="#t_vector">vector</a>
+of floating point values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
+
<p>The value produced is the floating point quotient of the two operands.</p>
+
<h5>Example:</h5>
-<pre> <result> = fdiv float 4.0, %var <i>; yields {float}:result = 4.0 / %var</i>
+
+<pre>
+ <result> = fdiv float 4.0, %var <i>; yields {float}:result = 4.0 / %var</i>
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"> <a name="i_urem">'<tt>urem</tt>' Instruction</a>
</div>
<p>The '<tt>urem</tt>' instruction returns the remainder from the
unsigned division of its two arguments.</p>
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>urem</tt>' instruction must be
-<a href="#t_integer">integer</a> values. Both arguments must have identical
-types. This instruction can also take <a href="#t_vector">vector</a> versions
-of the values in which case the elements must be integers.</p>
+<p>The two arguments to the '<tt>urem</tt>' instruction must be
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
<h5>Semantics:</h5>
<p>This instruction returns the unsigned integer <i>remainder</i> of a division.
This instruction always performs an unsigned division to get the remainder.</p>
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_srem">'<tt>srem</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_srem">'<tt>srem</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = srem <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+
+<pre>
+ <result> = srem <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>srem</tt>' instruction returns the remainder from the
signed division of its two operands. This instruction can also take
<a href="#t_vector">vector</a> versions of the values in which case
the elements must be integers.</p>
<h5>Arguments:</h5>
+
<p>The two arguments to the '<tt>srem</tt>' instruction must be
-<a href="#t_integer">integer</a> values. Both arguments must have identical
-types.</p>
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
+
<p>This instruction returns the <i>remainder</i> of a division (where the result
has the same sign as the dividend, <tt>var1</tt>), not the <i>modulo</i>
operator (where the result has the same sign as the divisor, <tt>var2</tt>) of
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_frem">'<tt>frem</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_frem">'<tt>frem</tt>' Instruction</a> </div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
<pre> <result> = frem <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
division of its two operands.</p>
<h5>Arguments:</h5>
<p>The two arguments to the '<tt>frem</tt>' instruction must be
-<a href="#t_floating">floating point</a> values. Both arguments must have
-identical types. This instruction can also take <a href="#t_vector">vector</a>
-versions of floating point values.</p>
+<a href="#t_floating">floating point</a> or <a href="#t_vector">vector</a>
+of floating point values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
+
<p>This instruction returns the <i>remainder</i> of a division.
The remainder has the same sign as the dividend.</p>
+
<h5>Example:</h5>
-<pre> <result> = frem float 4.0, %var <i>; yields {float}:result = 4.0 % %var</i>
+
+<pre>
+ <result> = frem float 4.0, %var <i>; yields {float}:result = 4.0 % %var</i>
</pre>
</div>
<p>Both arguments to the '<tt>shl</tt>' instruction must be the same <a
href="#t_integer">integer</a> type. '<tt>var2</tt>' is treated as an
-unsigned value.</p>
+unsigned value. This instruction does not support
+<a href="#t_vector">vector</a> operands.</p>
<h5>Semantics:</h5>
<h5>Arguments:</h5>
<p>Both arguments to the '<tt>lshr</tt>' instruction must be the same
<a href="#t_integer">integer</a> type. '<tt>var2</tt>' is treated as an
-unsigned value.</p>
+unsigned value. This instruction does not support
+<a href="#t_vector">vector</a> operands.</p>
<h5>Semantics:</h5>
<h5>Arguments:</h5>
<p>Both arguments to the '<tt>ashr</tt>' instruction must be the same
<a href="#t_integer">integer</a> type. '<tt>var2</tt>' is treated as an
-unsigned value.</p>
+unsigned value. This instruction does not support
+<a href="#t_vector">vector</a> operands.</p>
<h5>Semantics:</h5>
<p>This instruction always performs an arithmetic shift right operation,
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"> <a name="i_and">'<tt>and</tt>'
Instruction</a> </div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = and <ty> <var1>, <var2> <i>; yields {ty}:result</i>
+
+<pre>
+ <result> = and <ty> <var1>, <var2> <i>; yields {ty}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>and</tt>' instruction returns the bitwise logical and of
its two operands.</p>
+
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>and</tt>' instruction must be <a
- href="#t_integer">integer</a> values. Both arguments must have
-identical types.</p>
+
+<p>The two arguments to the '<tt>and</tt>' instruction must be
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
<p>The truth table used for the '<tt>and</tt>' instruction is:</p>
<p> </p>
</table>
</div>
<h5>Example:</h5>
-<pre> <result> = and i32 4, %var <i>; yields {i32}:result = 4 & %var</i>
+<pre>
+ <result> = and i32 4, %var <i>; yields {i32}:result = 4 & %var</i>
<result> = and i32 15, 40 <i>; yields {i32}:result = 8</i>
<result> = and i32 4, 8 <i>; yields {i32}:result = 0</i>
</pre>
<p>The '<tt>or</tt>' instruction returns the bitwise logical inclusive
or of its two operands.</p>
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>or</tt>' instruction must be <a
- href="#t_integer">integer</a> values. Both arguments must have
-identical types.</p>
+
+<p>The two arguments to the '<tt>or</tt>' instruction must be
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
<h5>Semantics:</h5>
<p>The truth table used for the '<tt>or</tt>' instruction is:</p>
<p> </p>
or of its two operands. The <tt>xor</tt> is used to implement the
"one's complement" operation, which is the "~" operator in C.</p>
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>xor</tt>' instruction must be <a
- href="#t_integer">integer</a> values. Both arguments must have
-identical types.</p>
+<p>The two arguments to the '<tt>xor</tt>' instruction must be
+<a href="#t_integer">integer</a> or <a href="#t_vector">vector</a> of integer
+values. Both arguments must have identical types.</p>
+
<h5>Semantics:</h5>
+
<p>The truth table used for the '<tt>xor</tt>' instruction is:</p>
<p> </p>
<div style="align: center">
The first operand of an '<tt>extractvalue</tt>' instruction is a
value of <a href="#t_struct">struct</a> or <a href="#t_array">array</a>
type. The operands are constant indices to specify which value to extract
-in the same manner as indices in a
+in a similar manner as indices in a
'<tt><a href="#i_getelementptr">getelementptr</a></tt>' instruction.
</p>
<h5>Example:</h5>
<pre>
- %result = extractvalue {i32, float} %agg, i32 0 <i>; yields i32</i>
+ %result = extractvalue {i32, float} %agg, 0 <i>; yields i32</i>
</pre>
</div>
<h5>Syntax:</h5>
<pre>
- <result> = insertvalue <aggregate type> <val>, <ty> <val>, i32 <idx> <i>; yields <n x <ty>></i>
+ <result> = insertvalue <aggregate type> <val>, <ty> <val>, <idx> <i>; yields <n x <ty>></i>
</pre>
<h5>Overview:</h5>
The first operand of an '<tt>insertvalue</tt>' instruction is a
value of <a href="#t_struct">struct</a> or <a href="#t_array">array</a> type.
The second operand is a first-class value to insert.
-type of the first operand. The following operands are constant indices
-indicating the position at which to insert the value in the same manner as
+The following operands are constant indices
+indicating the position at which to insert the value in a similar manner as
indices in a
'<tt><a href="#i_getelementptr">getelementptr</a></tt>' instruction.
The value to insert must have the same type as the value identified
<h5>Example:</h5>
<pre>
- %result = insertvalue {i32, float} %agg, i32 1, i32 0 <i>; yields {i32, float}</i>
+ %result = insertvalue {i32, float} %agg, 1, 0 <i>; yields {i32, float}</i>
</pre>
</div>
</pre>
<h5>Overview:</h5>
+
<p>The '<tt>bitcast</tt>' instruction converts <tt>value</tt> to type
<tt>ty2</tt> without changing any bits.</p>
<h5>Arguments:</h5>
+
<p>The '<tt>bitcast</tt>' instruction takes a value to cast, which must be
a first class value, and a type to cast it to, which must also be a <a
href="#t_firstclass">first class</a> type. The bit sizes of <tt>value</tt>
and the destination type, <tt>ty2</tt>, must be identical. If the source
-type is a pointer, the destination type must also be a pointer.</p>
+type is a pointer, the destination type must also be a pointer. This
+instruction supports bitwise conversion of vectors to integers and to vectors
+of other types (as long as they have the same size).</p>
<h5>Semantics:</h5>
<p>The '<tt>bitcast</tt>' instruction converts <tt>value</tt> to type
<h5>Example:</h5>
<pre>
- <result> = vicmp eq <2 x i32> < i32 4, i32 0 >, < i32 5, i32 0 > <i>; yields: result=<2 x i32> < i32 0, i32 -1 ></i>
- <result> = vicmp ult <2 x i8> < i8 1, i8 2 >, < i8 2, i8 2> <i>; yields: result=<2 x i8> < i8 -1, i8 0 ></i>
+ <result> = vicmp eq <2 x i32> < i32 4, i32 0>, < i32 5, i32 0> <i>; yields: result=<2 x i32> < i32 0, i32 -1 ></i>
+ <result> = vicmp ult <2 x i8 > < i8 1, i8 2>, < i8 2, i8 2 > <i>; yields: result=<2 x i8> < i8 -1, i8 0 ></i>
</pre>
</div>
<h5>Example:</h5>
<pre>
- <result> = vfcmp oeq <2 x float> < float 4, float 0 >, < float 5, float 0 > <i>; yields: result=<2 x i32> < i32 0, i32 -1 ></i>
- <result> = vfcmp ult <2 x double> < double 1, double 2 >, < double 2, double 2> <i>; yields: result=<2 x i64> < i64 -1, i64 0 ></i>
+ <result> = vfcmp oeq <2 x float> < float 4, float 0 >, < float 5, float 0 > <i>; yields: result=<2 x i32> < i32 0, i32 -1 ></i>
+ <result> = vfcmp ult <2 x double> < double 1, double 2 >, < double 2, double 2> <i>; yields: result=<2 x i64> < i64 -1, i64 0 ></i>
</pre>
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_phi">'<tt>phi</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_phi">'<tt>phi</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
+
<pre> <result> = phi <ty> [ <val0>, <label0>], ...<br></pre>
<h5>Overview:</h5>
<p>The '<tt>phi</tt>' instruction is used to implement the φ node in
the SSA graph representing the function.</p>
<h5>Arguments:</h5>
+
<p>The type of the incoming values is specified with the first type
field. After this, the '<tt>phi</tt>' instruction takes a list of pairs
as arguments, with one pair for each predecessor basic block of the
current block. Only values of <a href="#t_firstclass">first class</a>
type may be used as the value arguments to the PHI node. Only labels
may be used as the label arguments.</p>
+
<p>There must be no non-phi instructions between the start of a basic
block and the PHI instructions: i.e. PHI instructions must be first in
a basic block.</p>
+
<h5>Semantics:</h5>
+
<p>At runtime, the '<tt>phi</tt>' instruction logically takes on the value
specified by the pair corresponding to the predecessor basic block that executed
just prior to the current block.</p>
+
<h5>Example:</h5>
-<pre>Loop: ; Infinite loop that counts from 0 on up...<br> %indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]<br> %nextindvar = add i32 %indvar, 1<br> br label %Loop<br></pre>
+<pre>
+Loop: ; Infinite loop that counts from 0 on up...
+ %indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
+ %nextindvar = add i32 %indvar, 1
+ br label %Loop
+</pre>
</div>
<!-- _______________________________________________________________________ -->
<h5>Arguments:</h5>
<p>
-The '<tt>select</tt>' instruction requires a boolean value indicating the condition, and two values of the same <a href="#t_firstclass">first class</a> type.
+The '<tt>select</tt>' instruction requires an 'i1' value indicating the
+condition, and two values of the same <a href="#t_firstclass">first class</a>
+type. If the val1/val2 are vectors, the entire vectors are selected, not
+individual elements.
</p>
<h5>Semantics:</h5>
<p>
-If the boolean condition evaluates to true, the instruction returns the first
+If the i1 condition evaluates is 1, the instruction returns the first
value argument; otherwise, it returns the second value argument.
</p>