Revise FutureFeatures.md (#1342)

* Now we have IEEE 754-2019 instead of IEEE 754-2008

* Add 64bit version for additional integer operators

1 files changed, 16 insertions, 6 deletions

diff --git a/FutureFeatures.md b/FutureFeatures.md
index 36d4b28..7ed751b 100644
--- a/FutureFeatures.md
+++ b/FutureFeatures.md
@@ -273,11 +273,21 @@ use cases:
   * `i32.abs_s`: signed absolute value (traps on `INT32_MIN`)
   * `i32.bswap`: sign-agnostic reverse bytes (endian conversion)
   * `i32.bswap16`: sign-agnostic, `bswap16(x)` is `((x>>8)&255)|((x&255)<<8)`
+  * `i64.min_s`: signed minimum
+  * `i64.max_s`: signed maximum
+  * `i64.min_u`: unsigned minimum
+  * `i64.max_u`: unsigned maximum
+  * `i64.sext`: sign-agnostic `sext(x, y)` is `shr_s(shl(x,y),y)`
+  * `i64.abs_s`: signed absolute value (traps on `INT64_MIN`)
+  * `i64.bswap`: sign-agnostic reverse bytes (endian conversion)
 
 * The following operators are just potentially interesting.
   * `i32.clrs`: sign-agnostic count leading redundant sign bits (defined for
     all values, including 0)
   * `i32.floor_div_s`: signed division (result is [floored](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions))
+  * `i64.clrs`: sign-agnostic count leading redundant sign bits (defined for
+    all values, including 0)
+  * `i64.floor_div_s`: signed division (result is [floored](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions))
 
 * The following 64-bit-only operators are potentially interesting as well.
   * `i64.mor`: sign-agnostic [8x8 bit-matrix multiply with or](http://mmix.cs.hm.edu/doc/instructions-en.html#MOR)
@@ -287,13 +297,13 @@ use cases:
 
   * `f32.minnum`: minimum; if exactly one operand is NaN, returns the other operand
   * `f32.maxnum`: maximum; if exactly one operand is NaN, returns the other operand
-  * `f32.fma`: fused multiply-add (results always conforming to IEEE 754-2008)
+  * `f32.fma`: fused multiply-add (results always conforming to IEEE 754-2019)
   * `f64.minnum`: minimum; if exactly one operand is NaN, returns the other operand
   * `f64.maxnum`: maximum; if exactly one operand is NaN, returns the other operand
-  * `f64.fma`: fused multiply-add (results always conforming to IEEE 754-2008)
+  * `f64.fma`: fused multiply-add (results always conforming to IEEE 754-2019)
 
 `minnum` and `maxnum` operators would treat `-0.0` as being effectively less
-than `0.0`. Also, it's advisable to follow the IEEE 754-2018 draft, which has
+than `0.0`. Also, it's advisable to follow the IEEE 754-2019, which has
 removed IEEE 754-2008's `minNum` and `maxNum` (which return qNaN when either
 operand is sNaN) and replaced them with `minimumNumber` and `maximumNumber`,
 which prefer to return a number even when one operand is sNaN.
@@ -325,12 +335,12 @@ so there's nothing preventing WebAssembly applications from linking to an
 appropriate emulation library and getting similarly performant results.
 Emulation libraries would have more flexibility to offer approximation
 techniques such as double-double arithmetic. If we standardize 128-bit
-floating point in WebAssembly, it will probably be standard IEEE 754-2008
+floating point in WebAssembly, it will probably be standard IEEE 754-2019
 quadruple precision.
 
-### Full IEEE 754-2008 conformance
+### Full IEEE 754-2019 conformance
 
-WebAssembly floating point conforms IEEE 754-2008 in most respects, but there
+WebAssembly floating point conforms IEEE 754-2019 in most respects, but there
 are a few areas that are
 [not yet covered](Semantics.md#floating-point-operators).