diff --git a/llvm/docs/LangRef.html b/llvm/docs/LangRef.html index 160a3e251ad8..50062da33d3e 100644 --- a/llvm/docs/LangRef.html +++ b/llvm/docs/LangRef.html @@ -106,7 +106,8 @@
  • 'phi' Instruction
  • 'cast .. to' Instruction
  • 'select' Instruction
    • -
  • 'vset' Instruction
    • +
  • 'vsetint' Instruction
    • +
  • 'vsetfp' Instruction
  • 'vselect' Instruction
  • 'extractelement' Instruction
  • 'insertelement' Instruction
    • @@ -2331,56 +2332,50 @@ value argument; otherwise, it returns the second value argument. -
    'vset' +
    'vsetint' Instruction
    Syntax:
    -
    <result> = vset <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
+
    <result> = vsetint <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
 
    
 
 
    Overview:
    
 
-
    The 'vset' instruction returns a vector of boolean
-values representing, at each position, the result of the comparison
-between the values at that position in the two operands.
    
+
    The 'vsetint' instruction takes two integer vectors and
+returns a vector of boolean values representing, at each position, the
+result of the comparison between the values at that position in the
+two operands.
    
 
 
    Arguments:
    
 
-
    The arguments to a 'vset' instruction are a comparison
+
    The arguments to a 'vsetint' instruction are a comparison
 operation and two value arguments.  The value arguments must be of packed type, and they must have identical types.
-For value arguments of integral element type, the operation argument
-must be one of eq, ne, lt, gt,
-le, ge, ult, ugt, ule,
-uge, true, and false.  For value arguments
-of floating point element type, the operation argument must be one of
-eq, ne, lt, gt, le,
-ge, oeq, one, olt, ogt,
-ole, oge, ueq, une, ult,
-ugt, ule, uge, o, u,
-true, and false.  The result is a packed
-bool value with the same length as each operand.
    
+href="#t_integral">integral packed type,
+and they must have identical types.  The operation argument must be
+one of eq, ne, slt, sgt,
+sle, sge, ult, ugt, ule,
+uge, true, and false.  The result is a
+packed bool value with the same length as each operand.
    
 
 
    Semantics:
    
 
-
    The following table shows the semantics of 'vset' for
-integral value arguments.  For each position of the result, the
-comparison is done on the corresponding positions of the two value
-arguments.  Note that the signedness of the comparison depends on the
-comparison opcode and not on the signedness of the value
-operands.  E.g., vset lt <4 x unsigned> %x, %y does an
-elementwise signed comparison of %x and
-%y.
    
+
    The following table shows the semantics of 'vsetint'.  For
+each position of the result, the comparison is done on the
+corresponding positions of the two value arguments.  Note that the
+signedness of the comparison depends on the comparison opcode and
+not on the signedness of the value operands.  E.g., vsetint
+slt <4 x unsigned> %x, %y does an elementwise signed
+comparison of %x and %y.
    
 
 
-    
-    
-    
-    
+    
+    
+    
+    
@@ -2390,7 +2385,47 @@ elementwise signed comparison of %x and
   
    
   
     
    OperationResult is true iffComparison is
    
     
    eqvar1 == var2--
    
     
    nevar1 != var2--
    ltvar1 < var2signed
    gtvar1 > var2signed
    levar1 <= var2signed
    gevar1 >= var2signed
    sltvar1 < var2signed
    sgtvar1 > var2signed
    slevar1 <= var2signed
    sgevar1 >= var2signed
    
     
    ultvar1 < var2unsigned
    
     
    ugtvar1 > var2unsigned
    
     
    ulevar1 <= var2unsigned
    
 
    
 
-
    The following table shows the semantics of 'vset' for
+
    Example:
    
+
      <result> = vsetint eq <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, false
+  <result> = vsetint ne <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, true
+  <result> = vsetint slt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetint sgt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
+  <result> = vsetint sle <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetint sge <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
+
    
+
    + + +
    'vsetfp' +Instruction
    +
    +
    Syntax:
    +
    <result> = vsetfp <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
+
    + +
    Overview:
    + +

    The 'vsetfp' instruction takes two floating point vector +arguments and returns a vector of boolean values representing, at each +position, the result of the comparison between the values at that +position in the two operands.

    + +
    Arguments:
    + +

    The arguments to a 'vsetfp' instruction are a comparison +operation and two value arguments. The value arguments must be of floating point packed +type, and they must have identical types. The operation argument must +be one of eq, ne, lt, gt, +le, ge, oeq, one, olt, +ogt, ole, oge, ueq, une, +ult, ugt, ule, uge, o, +u, true, and false. The result is a packed +bool value with the same length as each operand.

    + +
    Semantics:
    + +

    The following table shows the semantics of 'vsetfp' for floating point types. If either operand is a floating point Not a Number (NaN) value, the operation is unordered, and the value in the first column below is produced at that position. Otherwise, the @@ -2426,12 +2461,12 @@ produced.

    Example:
    -
      <result> = vset eq <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, false
-  <result> = vset ne <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, true
-  <result> = vset lt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vset gt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
-  <result> = vset le <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vset ge <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
+
      <result> = vsetfp eq <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = false, false
+  <result> = vsetfp ne <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = true, true
+  <result> = vsetfp lt <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetfp gt <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = false, true
+  <result> = vsetfp le <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetfp ge <2 x float> <float 0, float 1>, <float 1, float 0>      ; yields {<2 x bool>}:result = false, true