all: rename WebAssembly instructions according to spec changes

The names of some instructions have been updated in the WebAssembly
specification to be more consistent, see
https://github.com/WebAssembly/spec/commit/994591e51c9df9e7ef980b04d660709b79982f75.
This change to the spec is possible because it is still in a draft
state.

Go's support for WebAssembly is still experimental and thus excempt from
the compatibility promise. Being consistent with the spec should
warrant this breaking change to the assembly instruction names.

Change-Id: Iafb8b18ee7f55dd0e23c6c7824aa1fad43117ef1
Reviewed-on: https://go-review.googlesource.com/c/153797
Run-TryBot: Richard Musiol <neelance@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

14 files changed, 129 insertions, 129 deletions

diff --git a/src/cmd/compile/internal/ssa/gen/Wasm.rules b/src/cmd/compile/internal/ssa/gen/Wasm.rules
index 41d8d1122d..b7ecae7d8c 100644
--- a/src/cmd/compile/internal/ssa/gen/Wasm.rules
+++ b/src/cmd/compile/internal/ssa/gen/Wasm.rules
@@ -72,23 +72,23 @@
 (Trunc16to8         x) -> x
 
 // Lowering float <-> int
-(Cvt32to32F x) -> (LoweredRound32F (F64ConvertSI64 (SignExt32to64 x)))
-(Cvt32to64F x) -> (F64ConvertSI64 (SignExt32to64 x))
-(Cvt64to32F x) -> (LoweredRound32F (F64ConvertSI64 x))
-(Cvt64to64F x) -> (F64ConvertSI64 x)
-(Cvt32Uto32F x) -> (LoweredRound32F (F64ConvertUI64 (ZeroExt32to64 x)))
-(Cvt32Uto64F x) -> (F64ConvertUI64 (ZeroExt32to64 x))
-(Cvt64Uto32F x) -> (LoweredRound32F (F64ConvertUI64 x))
-(Cvt64Uto64F x) -> (F64ConvertUI64 x)
+(Cvt32to32F x) -> (LoweredRound32F (F64ConvertI64S (SignExt32to64 x)))
+(Cvt32to64F x) -> (F64ConvertI64S (SignExt32to64 x))
+(Cvt64to32F x) -> (LoweredRound32F (F64ConvertI64S x))
+(Cvt64to64F x) -> (F64ConvertI64S x)
+(Cvt32Uto32F x) -> (LoweredRound32F (F64ConvertI64U (ZeroExt32to64 x)))
+(Cvt32Uto64F x) -> (F64ConvertI64U (ZeroExt32to64 x))
+(Cvt64Uto32F x) -> (LoweredRound32F (F64ConvertI64U x))
+(Cvt64Uto64F x) -> (F64ConvertI64U x)
 
-(Cvt32Fto32 x) -> (I64TruncSF64 x)
-(Cvt32Fto64 x) -> (I64TruncSF64 x)
-(Cvt64Fto32 x) -> (I64TruncSF64 x)
-(Cvt64Fto64 x) -> (I64TruncSF64 x)
-(Cvt32Fto32U x) -> (I64TruncUF64 x)
-(Cvt32Fto64U x) -> (I64TruncUF64 x)
-(Cvt64Fto32U x) -> (I64TruncUF64 x)
-(Cvt64Fto64U x) -> (I64TruncUF64 x)
+(Cvt32Fto32 x) -> (I64TruncF64S x)
+(Cvt32Fto64 x) -> (I64TruncF64S x)
+(Cvt64Fto32 x) -> (I64TruncF64S x)
+(Cvt64Fto64 x) -> (I64TruncF64S x)
+(Cvt32Fto32U x) -> (I64TruncF64U x)
+(Cvt32Fto64U x) -> (I64TruncF64U x)
+(Cvt64Fto32U x) -> (I64TruncF64U x)
+(Cvt64Fto64U x) -> (I64TruncF64U x)
 
 (Cvt32Fto64F x) -> x
 (Cvt64Fto32F x) -> (LoweredRound32F x)
diff --git a/src/cmd/compile/internal/ssa/gen/WasmOps.go b/src/cmd/compile/internal/ssa/gen/WasmOps.go
index e0f2f92a3f..c0ad9498ff 100644
--- a/src/cmd/compile/internal/ssa/gen/WasmOps.go
+++ b/src/cmd/compile/internal/ssa/gen/WasmOps.go
@@ -187,10 +187,10 @@ func init() {
 		{name: "F64Mul", asm: "F64Mul", argLength: 2, reg: fp21, typ: "Float64"}, // arg0 * arg1
 		{name: "F64Div", asm: "F64Div", argLength: 2, reg: fp21, typ: "Float64"}, // arg0 / arg1
 
-		{name: "I64TruncSF64", asm: "I64TruncSF64", argLength: 1, reg: regInfo{inputs: []regMask{fp}, outputs: []regMask{gp}}, typ: "Int64"},       // truncates the float arg0 to a signed integer
-		{name: "I64TruncUF64", asm: "I64TruncUF64", argLength: 1, reg: regInfo{inputs: []regMask{fp}, outputs: []regMask{gp}}, typ: "Int64"},       // truncates the float arg0 to an unsigned integer
-		{name: "F64ConvertSI64", asm: "F64ConvertSI64", argLength: 1, reg: regInfo{inputs: []regMask{gp}, outputs: []regMask{fp}}, typ: "Float64"}, // converts the signed integer arg0 to a float
-		{name: "F64ConvertUI64", asm: "F64ConvertUI64", argLength: 1, reg: regInfo{inputs: []regMask{gp}, outputs: []regMask{fp}}, typ: "Float64"}, // converts the unsigned integer arg0 to a float
+		{name: "I64TruncF64S", asm: "I64TruncF64S", argLength: 1, reg: regInfo{inputs: []regMask{fp}, outputs: []regMask{gp}}, typ: "Int64"},       // truncates the float arg0 to a signed integer
+		{name: "I64TruncF64U", asm: "I64TruncF64U", argLength: 1, reg: regInfo{inputs: []regMask{fp}, outputs: []regMask{gp}}, typ: "Int64"},       // truncates the float arg0 to an unsigned integer
+		{name: "F64ConvertI64S", asm: "F64ConvertI64S", argLength: 1, reg: regInfo{inputs: []regMask{gp}, outputs: []regMask{fp}}, typ: "Float64"}, // converts the signed integer arg0 to a float
+		{name: "F64ConvertI64U", asm: "F64ConvertI64U", argLength: 1, reg: regInfo{inputs: []regMask{gp}, outputs: []regMask{fp}}, typ: "Float64"}, // converts the unsigned integer arg0 to a float
 	}
 
 	archs = append(archs, arch{
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 2278407a26..948bbdc32a 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2075,10 +2075,10 @@ const (
 	OpWasmF64Sub
 	OpWasmF64Mul
 	OpWasmF64Div
-	OpWasmI64TruncSF64
-	OpWasmI64TruncUF64
-	OpWasmF64ConvertSI64
-	OpWasmF64ConvertUI64
+	OpWasmI64TruncF64S
+	OpWasmI64TruncF64U
+	OpWasmF64ConvertI64S
+	OpWasmF64ConvertI64U
 
 	OpAdd8
 	OpAdd16
@@ -28000,9 +28000,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:   "I64TruncSF64",
+		name:   "I64TruncF64S",
 		argLen: 1,
-		asm:    wasm.AI64TruncSF64,
+		asm:    wasm.AI64TruncF64S,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
@@ -28013,9 +28013,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:   "I64TruncUF64",
+		name:   "I64TruncF64U",
 		argLen: 1,
-		asm:    wasm.AI64TruncUF64,
+		asm:    wasm.AI64TruncF64U,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
@@ -28026,9 +28026,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:   "F64ConvertSI64",
+		name:   "F64ConvertI64S",
 		argLen: 1,
-		asm:    wasm.AF64ConvertSI64,
+		asm:    wasm.AF64ConvertI64S,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65535}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15
@@ -28039,9 +28039,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:   "F64ConvertUI64",
+		name:   "F64ConvertI64U",
 		argLen: 1,
-		asm:    wasm.AF64ConvertUI64,
+		asm:    wasm.AF64ConvertI64U,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65535}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index e14d6251be..1b7b5022da 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -913,10 +913,10 @@ func rewriteValueWasm_OpConvert_0(v *Value) bool {
 func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
-	// result: (I64TruncSF64 x)
+	// result: (I64TruncF64S x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncSF64)
+		v.reset(OpWasmI64TruncF64S)
 		v.AddArg(x)
 		return true
 	}
@@ -924,10 +924,10 @@ func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool {
 func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool {
 	// match: (Cvt32Fto32U x)
 	// cond:
-	// result: (I64TruncUF64 x)
+	// result: (I64TruncF64U x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncUF64)
+		v.reset(OpWasmI64TruncF64U)
 		v.AddArg(x)
 		return true
 	}
@@ -935,10 +935,10 @@ func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool {
 func rewriteValueWasm_OpCvt32Fto64_0(v *Value) bool {
 	// match: (Cvt32Fto64 x)
 	// cond:
-	// result: (I64TruncSF64 x)
+	// result: (I64TruncF64S x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncSF64)
+		v.reset(OpWasmI64TruncF64S)
 		v.AddArg(x)
 		return true
 	}
@@ -958,10 +958,10 @@ func rewriteValueWasm_OpCvt32Fto64F_0(v *Value) bool {
 func rewriteValueWasm_OpCvt32Fto64U_0(v *Value) bool {
 	// match: (Cvt32Fto64U x)
 	// cond:
-	// result: (I64TruncUF64 x)
+	// result: (I64TruncF64U x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncUF64)
+		v.reset(OpWasmI64TruncF64U)
 		v.AddArg(x)
 		return true
 	}
@@ -973,11 +973,11 @@ func rewriteValueWasm_OpCvt32Uto32F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt32Uto32F x)
 	// cond:
-	// result: (LoweredRound32F (F64ConvertUI64 (ZeroExt32to64 x)))
+	// result: (LoweredRound32F (F64ConvertI64U (ZeroExt32to64 x)))
 	for {
 		x := v.Args[0]
 		v.reset(OpWasmLoweredRound32F)
-		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertUI64, typ.Float64)
+		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64U, typ.Float64)
 		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
 		v1.AddArg(x)
 		v0.AddArg(v1)
@@ -992,10 +992,10 @@ func rewriteValueWasm_OpCvt32Uto64F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt32Uto64F x)
 	// cond:
-	// result: (F64ConvertUI64 (ZeroExt32to64 x))
+	// result: (F64ConvertI64U (ZeroExt32to64 x))
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmF64ConvertUI64)
+		v.reset(OpWasmF64ConvertI64U)
 		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
 		v0.AddArg(x)
 		v.AddArg(v0)
@@ -1009,11 +1009,11 @@ func rewriteValueWasm_OpCvt32to32F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt32to32F x)
 	// cond:
-	// result: (LoweredRound32F (F64ConvertSI64 (SignExt32to64 x)))
+	// result: (LoweredRound32F (F64ConvertI64S (SignExt32to64 x)))
 	for {
 		x := v.Args[0]
 		v.reset(OpWasmLoweredRound32F)
-		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertSI64, typ.Float64)
+		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64S, typ.Float64)
 		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
 		v1.AddArg(x)
 		v0.AddArg(v1)
@@ -1028,10 +1028,10 @@ func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt32to64F x)
 	// cond:
-	// result: (F64ConvertSI64 (SignExt32to64 x))
+	// result: (F64ConvertI64S (SignExt32to64 x))
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmF64ConvertSI64)
+		v.reset(OpWasmF64ConvertI64S)
 		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
 		v0.AddArg(x)
 		v.AddArg(v0)
@@ -1041,10 +1041,10 @@ func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
-	// result: (I64TruncSF64 x)
+	// result: (I64TruncF64S x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncSF64)
+		v.reset(OpWasmI64TruncF64S)
 		v.AddArg(x)
 		return true
 	}
@@ -1063,10 +1063,10 @@ func rewriteValueWasm_OpCvt64Fto32F_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool {
 	// match: (Cvt64Fto32U x)
 	// cond:
-	// result: (I64TruncUF64 x)
+	// result: (I64TruncF64U x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncUF64)
+		v.reset(OpWasmI64TruncF64U)
 		v.AddArg(x)
 		return true
 	}
@@ -1074,10 +1074,10 @@ func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool {
 	// match: (Cvt64Fto64 x)
 	// cond:
-	// result: (I64TruncSF64 x)
+	// result: (I64TruncF64S x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncSF64)
+		v.reset(OpWasmI64TruncF64S)
 		v.AddArg(x)
 		return true
 	}
@@ -1085,10 +1085,10 @@ func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64Fto64U_0(v *Value) bool {
 	// match: (Cvt64Fto64U x)
 	// cond:
-	// result: (I64TruncUF64 x)
+	// result: (I64TruncF64U x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmI64TruncUF64)
+		v.reset(OpWasmI64TruncF64U)
 		v.AddArg(x)
 		return true
 	}
@@ -1100,11 +1100,11 @@ func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt64Uto32F x)
 	// cond:
-	// result: (LoweredRound32F (F64ConvertUI64 x))
+	// result: (LoweredRound32F (F64ConvertI64U x))
 	for {
 		x := v.Args[0]
 		v.reset(OpWasmLoweredRound32F)
-		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertUI64, typ.Float64)
+		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64U, typ.Float64)
 		v0.AddArg(x)
 		v.AddArg(v0)
 		return true
@@ -1113,10 +1113,10 @@ func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64Uto64F_0(v *Value) bool {
 	// match: (Cvt64Uto64F x)
 	// cond:
-	// result: (F64ConvertUI64 x)
+	// result: (F64ConvertI64U x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmF64ConvertUI64)
+		v.reset(OpWasmF64ConvertI64U)
 		v.AddArg(x)
 		return true
 	}
@@ -1128,11 +1128,11 @@ func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool {
 	_ = typ
 	// match: (Cvt64to32F x)
 	// cond:
-	// result: (LoweredRound32F (F64ConvertSI64 x))
+	// result: (LoweredRound32F (F64ConvertI64S x))
 	for {
 		x := v.Args[0]
 		v.reset(OpWasmLoweredRound32F)
-		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertSI64, typ.Float64)
+		v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64S, typ.Float64)
 		v0.AddArg(x)
 		v.AddArg(v0)
 		return true
@@ -1141,10 +1141,10 @@ func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool {
 func rewriteValueWasm_OpCvt64to64F_0(v *Value) bool {
 	// match: (Cvt64to64F x)
 	// cond:
-	// result: (F64ConvertSI64 x)
+	// result: (F64ConvertI64S x)
 	for {
 		x := v.Args[0]
-		v.reset(OpWasmF64ConvertSI64)
+		v.reset(OpWasmF64ConvertI64S)
 		v.AddArg(x)
 		return true
 	}
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 897d6146c5..604c88247f 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -283,13 +283,13 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.OpWasmI64Eqz:
 		getValue64(s, v.Args[0])
 		s.Prog(v.Op.Asm())
-		s.Prog(wasm.AI64ExtendUI32)
+		s.Prog(wasm.AI64ExtendI32U)
 
 	case ssa.OpWasmI64Eq, ssa.OpWasmI64Ne, ssa.OpWasmI64LtS, ssa.OpWasmI64LtU, ssa.OpWasmI64GtS, ssa.OpWasmI64GtU, ssa.OpWasmI64LeS, ssa.OpWasmI64LeU, ssa.OpWasmI64GeS, ssa.OpWasmI64GeU, ssa.OpWasmF64Eq, ssa.OpWasmF64Ne, ssa.OpWasmF64Lt, ssa.OpWasmF64Gt, ssa.OpWasmF64Le, ssa.OpWasmF64Ge:
 		getValue64(s, v.Args[0])
 		getValue64(s, v.Args[1])
 		s.Prog(v.Op.Asm())
-		s.Prog(wasm.AI64ExtendUI32)
+		s.Prog(wasm.AI64ExtendI32U)
 
 	case ssa.OpWasmI64Add, ssa.OpWasmI64Sub, ssa.OpWasmI64Mul, ssa.OpWasmI64DivU, ssa.OpWasmI64RemS, ssa.OpWasmI64RemU, ssa.OpWasmI64And, ssa.OpWasmI64Or, ssa.OpWasmI64Xor, ssa.OpWasmI64Shl, ssa.OpWasmI64ShrS, ssa.OpWasmI64ShrU, ssa.OpWasmF64Add, ssa.OpWasmF64Sub, ssa.OpWasmF64Mul, ssa.OpWasmF64Div:
 		getValue64(s, v.Args[0])
@@ -307,17 +307,17 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		s.Prog(wasm.AI64DivS)
 
-	case ssa.OpWasmI64TruncSF64:
+	case ssa.OpWasmI64TruncF64S:
 		getValue64(s, v.Args[0])
 		p := s.Prog(wasm.ACall)
 		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncS}
 
-	case ssa.OpWasmI64TruncUF64:
+	case ssa.OpWasmI64TruncF64U:
 		getValue64(s, v.Args[0])
 		p := s.Prog(wasm.ACall)
 		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncU}
 
-	case ssa.OpWasmF64Neg, ssa.OpWasmF64ConvertSI64, ssa.OpWasmF64ConvertUI64:
+	case ssa.OpWasmF64Neg, ssa.OpWasmF64ConvertI64S, ssa.OpWasmF64ConvertI64U:
 		getValue64(s, v.Args[0])
 		s.Prog(v.Op.Asm())
 
@@ -362,7 +362,7 @@ func getValue64(s *gc.SSAGenState, v *ssa.Value) {
 	reg := v.Reg()
 	getReg(s, reg)
 	if reg == wasm.REG_SP {
-		s.Prog(wasm.AI64ExtendUI32)
+		s.Prog(wasm.AI64ExtendI32U)
 	}
 }
 
diff --git a/src/cmd/internal/obj/wasm/a.out.go b/src/cmd/internal/obj/wasm/a.out.go
index 0e8196be60..f1830ba036 100644
--- a/src/cmd/internal/obj/wasm/a.out.go
+++ b/src/cmd/internal/obj/wasm/a.out.go
@@ -186,25 +186,25 @@ const (
 	AF64Copysign
 
 	AI32WrapI64
-	AI32TruncSF32
-	AI32TruncUF32
-	AI32TruncSF64
-	AI32TruncUF64
-	AI64ExtendSI32
-	AI64ExtendUI32
-	AI64TruncSF32
-	AI64TruncUF32
-	AI64TruncSF64
-	AI64TruncUF64
-	AF32ConvertSI32
-	AF32ConvertUI32
-	AF32ConvertSI64
-	AF32ConvertUI64
+	AI32TruncF32S
+	AI32TruncF32U
+	AI32TruncF64S
+	AI32TruncF64U
+	AI64ExtendI32S
+	AI64ExtendI32U
+	AI64TruncF32S
+	AI64TruncF32U
+	AI64TruncF64S
+	AI64TruncF64U
+	AF32ConvertI32S
+	AF32ConvertI32U
+	AF32ConvertI64S
+	AF32ConvertI64U
 	AF32DemoteF64
-	AF64ConvertSI32
-	AF64ConvertUI32
-	AF64ConvertSI64
-	AF64ConvertUI64
+	AF64ConvertI32S
+	AF64ConvertI32U
+	AF64ConvertI64S
+	AF64ConvertI64U
 	AF64PromoteF32
 	AI32ReinterpretF32
 	AI64ReinterpretF64
diff --git a/src/cmd/internal/obj/wasm/anames.go b/src/cmd/internal/obj/wasm/anames.go
index 369de3092d..7ef09d665e 100644
--- a/src/cmd/internal/obj/wasm/anames.go
+++ b/src/cmd/internal/obj/wasm/anames.go
@@ -153,25 +153,25 @@ var Anames = []string{
 	"F64Max",
 	"F64Copysign",
 	"I32WrapI64",
-	"I32TruncSF32",
-	"I32TruncUF32",
-	"I32TruncSF64",
-	"I32TruncUF64",
-	"I64ExtendSI32",
-	"I64ExtendUI32",
-	"I64TruncSF32",
-	"I64TruncUF32",
-	"I64TruncSF64",
-	"I64TruncUF64",
-	"F32ConvertSI32",
-	"F32ConvertUI32",
-	"F32ConvertSI64",
-	"F32ConvertUI64",
+	"I32TruncF32S",
+	"I32TruncF32U",
+	"I32TruncF64S",
+	"I32TruncF64U",
+	"I64ExtendI32S",
+	"I64ExtendI32U",
+	"I64TruncF32S",
+	"I64TruncF32U",
+	"I64TruncF64S",
+	"I64TruncF64U",
+	"F32ConvertI32S",
+	"F32ConvertI32U",
+	"F32ConvertI64S",
+	"F32ConvertI64U",
 	"F32DemoteF64",
-	"F64ConvertSI32",
-	"F64ConvertUI32",
-	"F64ConvertSI64",
-	"F64ConvertUI64",
+	"F64ConvertI32S",
+	"F64ConvertI32U",
+	"F64ConvertI64S",
+	"F64ConvertI64U",
 	"F64PromoteF32",
 	"I32ReinterpretF32",
 	"I64ReinterpretF64",
diff --git a/src/cmd/internal/obj/wasm/wasmobj.go b/src/cmd/internal/obj/wasm/wasmobj.go
index fbea103dcb..4a499b4f91 100644
--- a/src/cmd/internal/obj/wasm/wasmobj.go
+++ b/src/cmd/internal/obj/wasm/wasmobj.go
@@ -181,7 +181,7 @@ func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 		// Not
 		// If
 		//   Get SP
-		//   I64ExtendUI32
+		//   I64ExtendI32U
 		//   I64Const $framesize+8
 		//   I64Add
 		//   I64Load panic_argp(R0)
@@ -212,7 +212,7 @@ func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 		p = appendp(p, AIf)
 
 		p = appendp(p, AGet, regAddr(REG_SP))
-		p = appendp(p, AI64ExtendUI32)
+		p = appendp(p, AI64ExtendI32U)
 		p = appendp(p, AI64Const, constAddr(framesize+8))
 		p = appendp(p, AI64Add)
 		p = appendp(p, AI64Load, panicargp)
@@ -584,7 +584,7 @@ func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 				case obj.NAME_AUTO, obj.NAME_PARAM:
 					p = appendp(p, AGet, regAddr(get.From.Reg))
 					if get.From.Reg == REG_SP {
-						p = appendp(p, AI64ExtendUI32)
+						p = appendp(p, AI64ExtendI32U)
 					}
 					if get.From.Offset != 0 {
 						p = appendp(p, AI64Const, constAddr(get.From.Offset))
@@ -641,7 +641,7 @@ func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 					case obj.NAME_NONE, obj.NAME_PARAM, obj.NAME_AUTO:
 						p = appendp(p, AGet, regAddr(mov.From.Reg))
 						if mov.From.Reg == REG_SP {
-							p = appendp(p, AI64ExtendUI32)
+							p = appendp(p, AI64ExtendI32U)
 						}
 						p = appendp(p, AI64Const, constAddr(mov.From.Offset))
 						p = appendp(p, AI64Add)
@@ -654,7 +654,7 @@ func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 				case obj.TYPE_REG:
 					p = appendp(p, AGet, mov.From)
 					if mov.From.Reg == REG_SP {
-						p = appendp(p, AI64ExtendUI32)
+						p = appendp(p, AI64ExtendI32U)
 					}
 
 				case obj.TYPE_MEM:
@@ -788,13 +788,13 @@ func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 			reg := p.From.Reg
 			switch {
 			case reg >= REG_PC_F && reg <= REG_PAUSE:
-				w.WriteByte(0x23) // get_global
+				w.WriteByte(0x23) // global.get
 				writeUleb128(w, uint64(reg-REG_PC_F))
 			case reg >= REG_R0 && reg <= REG_R15:
-				w.WriteByte(0x20) // get_local (i64)
+				w.WriteByte(0x20) // local.get (i64)
 				writeUleb128(w, uint64(reg-REG_R0))
 			case reg >= REG_F0 && reg <= REG_F15:
-				w.WriteByte(0x20) // get_local (f64)
+				w.WriteByte(0x20) // local.get (f64)
 				writeUleb128(w, uint64(numI+(reg-REG_F0)))
 			default:
 				panic("bad Get: invalid register")
@@ -808,14 +808,14 @@ func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 			reg := p.To.Reg
 			switch {
 			case reg >= REG_PC_F && reg <= REG_PAUSE:
-				w.WriteByte(0x24) // set_global
+				w.WriteByte(0x24) // global.set
 				writeUleb128(w, uint64(reg-REG_PC_F))
 			case reg >= REG_R0 && reg <= REG_F15:
 				if p.Link.As == AGet && p.Link.From.Reg == reg {
-					w.WriteByte(0x22) // tee_local
+					w.WriteByte(0x22) // local.tee
 					p = p.Link
 				} else {
-					w.WriteByte(0x21) // set_local
+					w.WriteByte(0x21) // local.set
 				}
 				if reg <= REG_R15 {
 					writeUleb128(w, uint64(reg-REG_R0))
@@ -834,10 +834,10 @@ func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
 			reg := p.To.Reg
 			switch {
 			case reg >= REG_R0 && reg <= REG_R15:
-				w.WriteByte(0x22) // tee_local (i64)
+				w.WriteByte(0x22) // local.tee (i64)
 				writeUleb128(w, uint64(reg-REG_R0))
 			case reg >= REG_F0 && reg <= REG_F15:
-				w.WriteByte(0x22) // tee_local (f64)
+				w.WriteByte(0x22) // local.tee (f64)
 				writeUleb128(w, uint64(numI+(reg-REG_F0)))
 			default:
 				panic("bad Tee: invalid register")
diff --git a/src/internal/bytealg/compare_wasm.s b/src/internal/bytealg/compare_wasm.s
index b2a20a08f6..2d28215b1a 100644
--- a/src/internal/bytealg/compare_wasm.s
+++ b/src/internal/bytealg/compare_wasm.s
@@ -44,7 +44,7 @@ TEXT cmpbody<>(SB), NOSPLIT, $0-0
 	Get R4
 	I32WrapI64
 	Call memcmp<>(SB)
-	I64ExtendSI32
+	I64ExtendI32S
 	Set R5
 
 	Get R5
diff --git a/src/internal/bytealg/indexbyte_wasm.s b/src/internal/bytealg/indexbyte_wasm.s
index aae11b30a6..4d940a3bb0 100644
--- a/src/internal/bytealg/indexbyte_wasm.s
+++ b/src/internal/bytealg/indexbyte_wasm.s
@@ -12,7 +12,7 @@ TEXT ·IndexByte(SB), NOSPLIT, $0-40
 	I64Load b_len+8(FP)
 	I32WrapI64
 	Call memchr<>(SB)
-	I64ExtendSI32
+	I64ExtendI32S
 	Set R0
 
 	Get SP
@@ -35,7 +35,7 @@ TEXT ·IndexByteString(SB), NOSPLIT, $0-32
 	I64Load s_len+8(FP)
 	I32WrapI64
 	Call memchr<>(SB)
-	I64ExtendSI32
+	I64ExtendI32S
 	Set R0
 
 	I64Const $-1
diff --git a/src/reflect/asm_wasm.s b/src/reflect/asm_wasm.s
index 627e295769..63b4d94fca 100644
--- a/src/reflect/asm_wasm.s
+++ b/src/reflect/asm_wasm.s
@@ -16,7 +16,7 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 
 	Get SP
 	Get SP
-	I64ExtendUI32
+	I64ExtendI32U
 	I64Const $argframe+0(FP)
 	I64Add
 	I64Store $8
@@ -38,7 +38,7 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
 
 	Get SP
 	Get SP
-	I64ExtendUI32
+	I64ExtendI32U
 	I64Const $argframe+0(FP)
 	I64Add
 	I64Store $8
diff --git a/src/runtime/asm_wasm.s b/src/runtime/asm_wasm.s
index 374b9f73db..1d25ee899d 100644
--- a/src/runtime/asm_wasm.s
+++ b/src/runtime/asm_wasm.s
@@ -366,7 +366,7 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
 	Set RET1; \
 	\
 	Get SP; \
-	I64ExtendUI32; \
+	I64ExtendI32U; \
 	Get R0; \
 	I64Add; \
 	Set RET2; \
diff --git a/src/runtime/rt0_js_wasm.s b/src/runtime/rt0_js_wasm.s
index 50adbe2225..c4efd9637c 100644
--- a/src/runtime/rt0_js_wasm.s
+++ b/src/runtime/rt0_js_wasm.s
@@ -23,12 +23,12 @@ TEXT wasm_export_run(SB),NOSPLIT,$0
 
 	Get SP
 	Get R0 // argc
-	I64ExtendUI32
+	I64ExtendI32U
 	I64Store $0
 
 	Get SP
 	Get R1 // argv
-	I64ExtendUI32
+	I64ExtendI32U
 	I64Store $8
 
 	I32Const $runtime·rt0_go(SB)
diff --git a/src/runtime/sys_wasm.s b/src/runtime/sys_wasm.s
index 6e28656340..d7bab926dc 100644
--- a/src/runtime/sys_wasm.s
+++ b/src/runtime/sys_wasm.s
@@ -117,7 +117,7 @@ TEXT runtime·wasmTruncS(SB), NOSPLIT, $0-0
 	End
 
 	Get R0
-	I64TruncSF64
+	I64TruncF64S
 	Return
 
 TEXT runtime·wasmTruncU(SB), NOSPLIT, $0-0
@@ -146,7 +146,7 @@ TEXT runtime·wasmTruncU(SB), NOSPLIT, $0-0
 	End
 
 	Get R0
-	I64TruncUF64
+	I64TruncF64U
 	Return
 
 TEXT runtime·exitThread(SB), NOSPLIT, $0-0