[dev.ssa] cmd/compile: add max arg length to opcodes
Add the max arg length to opcodes and use it in zcse. Doesn't affect
speed, but allows better checking in checkFunc and removes the need
to keep a list of zero arg opcodes up to date.
Change-Id: I157c6587154604119720ec6228b767b6e52bb5c7
Reviewed-on: https://go-review.googlesource.com/19994
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Todd Neal <todd@tneal.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 9f53024..31e45c4 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -8,129 +8,129 @@
// 2-input arithmetic
// Types must be consistent with Go typing. Add, for example, must take two values
// of the same type and produces that same type.
- {name: "Add8", commutative: true}, // arg0 + arg1
- {name: "Add16", commutative: true},
- {name: "Add32", commutative: true},
- {name: "Add64", commutative: true},
- {name: "AddPtr"}, // For address calculations. arg0 is a pointer and arg1 is an int.
- {name: "Add32F"},
- {name: "Add64F"},
+ {name: "Add8", argLength: 2, commutative: true}, // arg0 + arg1
+ {name: "Add16", argLength: 2, commutative: true},
+ {name: "Add32", argLength: 2, commutative: true},
+ {name: "Add64", argLength: 2, commutative: true},
+ {name: "AddPtr", argLength: 2}, // For address calculations. arg0 is a pointer and arg1 is an int.
+ {name: "Add32F", argLength: 2},
+ {name: "Add64F", argLength: 2},
// TODO: Add64C, Add128C
- {name: "Sub8"}, // arg0 - arg1
- {name: "Sub16"},
- {name: "Sub32"},
- {name: "Sub64"},
- {name: "SubPtr"},
- {name: "Sub32F"},
- {name: "Sub64F"},
+ {name: "Sub8", argLength: 2}, // arg0 - arg1
+ {name: "Sub16", argLength: 2},
+ {name: "Sub32", argLength: 2},
+ {name: "Sub64", argLength: 2},
+ {name: "SubPtr", argLength: 2},
+ {name: "Sub32F", argLength: 2},
+ {name: "Sub64F", argLength: 2},
- {name: "Mul8", commutative: true}, // arg0 * arg1
- {name: "Mul16", commutative: true},
- {name: "Mul32", commutative: true},
- {name: "Mul64", commutative: true},
- {name: "Mul32F"},
- {name: "Mul64F"},
+ {name: "Mul8", argLength: 2, commutative: true}, // arg0 * arg1
+ {name: "Mul16", argLength: 2, commutative: true},
+ {name: "Mul32", argLength: 2, commutative: true},
+ {name: "Mul64", argLength: 2, commutative: true},
+ {name: "Mul32F", argLength: 2},
+ {name: "Mul64F", argLength: 2},
- {name: "Div32F"}, // arg0 / arg1
- {name: "Div64F"},
+ {name: "Div32F", argLength: 2}, // arg0 / arg1
+ {name: "Div64F", argLength: 2},
- {name: "Hmul8"}, // (arg0 * arg1) >> width
- {name: "Hmul8u"},
- {name: "Hmul16"},
- {name: "Hmul16u"},
- {name: "Hmul32"},
- {name: "Hmul32u"},
- {name: "Hmul64"},
- {name: "Hmul64u"},
+ {name: "Hmul8", argLength: 2}, // (arg0 * arg1) >> width
+ {name: "Hmul8u", argLength: 2},
+ {name: "Hmul16", argLength: 2},
+ {name: "Hmul16u", argLength: 2},
+ {name: "Hmul32", argLength: 2},
+ {name: "Hmul32u", argLength: 2},
+ {name: "Hmul64", argLength: 2},
+ {name: "Hmul64u", argLength: 2},
// Weird special instruction for strength reduction of divides.
- {name: "Avg64u"}, // (uint64(arg0) + uint64(arg1)) / 2, correct to all 64 bits.
+ {name: "Avg64u", argLength: 2}, // (uint64(arg0) + uint64(arg1)) / 2, correct to all 64 bits.
- {name: "Div8"}, // arg0 / arg1
- {name: "Div8u"},
- {name: "Div16"},
- {name: "Div16u"},
- {name: "Div32"},
- {name: "Div32u"},
- {name: "Div64"},
- {name: "Div64u"},
+ {name: "Div8", argLength: 2}, // arg0 / arg1
+ {name: "Div8u", argLength: 2},
+ {name: "Div16", argLength: 2},
+ {name: "Div16u", argLength: 2},
+ {name: "Div32", argLength: 2},
+ {name: "Div32u", argLength: 2},
+ {name: "Div64", argLength: 2},
+ {name: "Div64u", argLength: 2},
- {name: "Mod8"}, // arg0 % arg1
- {name: "Mod8u"},
- {name: "Mod16"},
- {name: "Mod16u"},
- {name: "Mod32"},
- {name: "Mod32u"},
- {name: "Mod64"},
- {name: "Mod64u"},
+ {name: "Mod8", argLength: 2}, // arg0 % arg1
+ {name: "Mod8u", argLength: 2},
+ {name: "Mod16", argLength: 2},
+ {name: "Mod16u", argLength: 2},
+ {name: "Mod32", argLength: 2},
+ {name: "Mod32u", argLength: 2},
+ {name: "Mod64", argLength: 2},
+ {name: "Mod64u", argLength: 2},
- {name: "And8", commutative: true}, // arg0 & arg1
- {name: "And16", commutative: true},
- {name: "And32", commutative: true},
- {name: "And64", commutative: true},
+ {name: "And8", argLength: 2, commutative: true}, // arg0 & arg1
+ {name: "And16", argLength: 2, commutative: true},
+ {name: "And32", argLength: 2, commutative: true},
+ {name: "And64", argLength: 2, commutative: true},
- {name: "Or8", commutative: true}, // arg0 | arg1
- {name: "Or16", commutative: true},
- {name: "Or32", commutative: true},
- {name: "Or64", commutative: true},
+ {name: "Or8", argLength: 2, commutative: true}, // arg0 | arg1
+ {name: "Or16", argLength: 2, commutative: true},
+ {name: "Or32", argLength: 2, commutative: true},
+ {name: "Or64", argLength: 2, commutative: true},
- {name: "Xor8", commutative: true}, // arg0 ^ arg1
- {name: "Xor16", commutative: true},
- {name: "Xor32", commutative: true},
- {name: "Xor64", commutative: true},
+ {name: "Xor8", argLength: 2, commutative: true}, // arg0 ^ arg1
+ {name: "Xor16", argLength: 2, commutative: true},
+ {name: "Xor32", argLength: 2, commutative: true},
+ {name: "Xor64", argLength: 2, commutative: true},
// For shifts, AxB means the shifted value has A bits and the shift amount has B bits.
- {name: "Lsh8x8"}, // arg0 << arg1
- {name: "Lsh8x16"},
- {name: "Lsh8x32"},
- {name: "Lsh8x64"},
- {name: "Lsh16x8"},
- {name: "Lsh16x16"},
- {name: "Lsh16x32"},
- {name: "Lsh16x64"},
- {name: "Lsh32x8"},
- {name: "Lsh32x16"},
- {name: "Lsh32x32"},
- {name: "Lsh32x64"},
- {name: "Lsh64x8"},
- {name: "Lsh64x16"},
- {name: "Lsh64x32"},
- {name: "Lsh64x64"},
+ {name: "Lsh8x8", argLength: 2}, // arg0 << arg1
+ {name: "Lsh8x16", argLength: 2},
+ {name: "Lsh8x32", argLength: 2},
+ {name: "Lsh8x64", argLength: 2},
+ {name: "Lsh16x8", argLength: 2},
+ {name: "Lsh16x16", argLength: 2},
+ {name: "Lsh16x32", argLength: 2},
+ {name: "Lsh16x64", argLength: 2},
+ {name: "Lsh32x8", argLength: 2},
+ {name: "Lsh32x16", argLength: 2},
+ {name: "Lsh32x32", argLength: 2},
+ {name: "Lsh32x64", argLength: 2},
+ {name: "Lsh64x8", argLength: 2},
+ {name: "Lsh64x16", argLength: 2},
+ {name: "Lsh64x32", argLength: 2},
+ {name: "Lsh64x64", argLength: 2},
- {name: "Rsh8x8"}, // arg0 >> arg1, signed
- {name: "Rsh8x16"},
- {name: "Rsh8x32"},
- {name: "Rsh8x64"},
- {name: "Rsh16x8"},
- {name: "Rsh16x16"},
- {name: "Rsh16x32"},
- {name: "Rsh16x64"},
- {name: "Rsh32x8"},
- {name: "Rsh32x16"},
- {name: "Rsh32x32"},
- {name: "Rsh32x64"},
- {name: "Rsh64x8"},
- {name: "Rsh64x16"},
- {name: "Rsh64x32"},
- {name: "Rsh64x64"},
+ {name: "Rsh8x8", argLength: 2}, // arg0 >> arg1, signed
+ {name: "Rsh8x16", argLength: 2},
+ {name: "Rsh8x32", argLength: 2},
+ {name: "Rsh8x64", argLength: 2},
+ {name: "Rsh16x8", argLength: 2},
+ {name: "Rsh16x16", argLength: 2},
+ {name: "Rsh16x32", argLength: 2},
+ {name: "Rsh16x64", argLength: 2},
+ {name: "Rsh32x8", argLength: 2},
+ {name: "Rsh32x16", argLength: 2},
+ {name: "Rsh32x32", argLength: 2},
+ {name: "Rsh32x64", argLength: 2},
+ {name: "Rsh64x8", argLength: 2},
+ {name: "Rsh64x16", argLength: 2},
+ {name: "Rsh64x32", argLength: 2},
+ {name: "Rsh64x64", argLength: 2},
- {name: "Rsh8Ux8"}, // arg0 >> arg1, unsigned
- {name: "Rsh8Ux16"},
- {name: "Rsh8Ux32"},
- {name: "Rsh8Ux64"},
- {name: "Rsh16Ux8"},
- {name: "Rsh16Ux16"},
- {name: "Rsh16Ux32"},
- {name: "Rsh16Ux64"},
- {name: "Rsh32Ux8"},
- {name: "Rsh32Ux16"},
- {name: "Rsh32Ux32"},
- {name: "Rsh32Ux64"},
- {name: "Rsh64Ux8"},
- {name: "Rsh64Ux16"},
- {name: "Rsh64Ux32"},
- {name: "Rsh64Ux64"},
+ {name: "Rsh8Ux8", argLength: 2}, // arg0 >> arg1, unsigned
+ {name: "Rsh8Ux16", argLength: 2},
+ {name: "Rsh8Ux32", argLength: 2},
+ {name: "Rsh8Ux64", argLength: 2},
+ {name: "Rsh16Ux8", argLength: 2},
+ {name: "Rsh16Ux16", argLength: 2},
+ {name: "Rsh16Ux32", argLength: 2},
+ {name: "Rsh16Ux64", argLength: 2},
+ {name: "Rsh32Ux8", argLength: 2},
+ {name: "Rsh32Ux16", argLength: 2},
+ {name: "Rsh32Ux32", argLength: 2},
+ {name: "Rsh32Ux64", argLength: 2},
+ {name: "Rsh64Ux8", argLength: 2},
+ {name: "Rsh64Ux16", argLength: 2},
+ {name: "Rsh64Ux32", argLength: 2},
+ {name: "Rsh64Ux64", argLength: 2},
// (Left) rotates replace pattern matches in the front end
// of (arg0 << arg1) ^ (arg0 >> (A-arg1))
@@ -152,102 +152,103 @@
// for rotates is hashing and crypto code with constant
// distance, rotate instructions are only substituted
// when arg1 is a constant between 1 and A-1, inclusive.
- {name: "Lrot8", aux: "Int64"},
- {name: "Lrot16", aux: "Int64"},
- {name: "Lrot32", aux: "Int64"},
- {name: "Lrot64", aux: "Int64"},
+ {name: "Lrot8", argLength: 1, aux: "Int64"},
+ {name: "Lrot16", argLength: 1, aux: "Int64"},
+ {name: "Lrot32", argLength: 1, aux: "Int64"},
+ {name: "Lrot64", argLength: 1, aux: "Int64"},
// 2-input comparisons
- {name: "Eq8", commutative: true}, // arg0 == arg1
- {name: "Eq16", commutative: true},
- {name: "Eq32", commutative: true},
- {name: "Eq64", commutative: true},
- {name: "EqPtr", commutative: true},
- {name: "EqInter"}, // arg0 or arg1 is nil; other cases handled by frontend
- {name: "EqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend
- {name: "Eq32F"},
- {name: "Eq64F"},
+ {name: "Eq8", argLength: 2, commutative: true}, // arg0 == arg1
+ {name: "Eq16", argLength: 2, commutative: true},
+ {name: "Eq32", argLength: 2, commutative: true},
+ {name: "Eq64", argLength: 2, commutative: true},
+ {name: "EqPtr", argLength: 2, commutative: true},
+ {name: "EqInter", argLength: 2}, // arg0 or arg1 is nil; other cases handled by frontend
+ {name: "EqSlice", argLength: 2}, // arg0 or arg1 is nil; other cases handled by frontend
+ {name: "Eq32F", argLength: 2},
+ {name: "Eq64F", argLength: 2},
- {name: "Neq8", commutative: true}, // arg0 != arg1
- {name: "Neq16", commutative: true},
- {name: "Neq32", commutative: true},
- {name: "Neq64", commutative: true},
- {name: "NeqPtr", commutative: true},
- {name: "NeqInter"}, // arg0 or arg1 is nil; other cases handled by frontend
- {name: "NeqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend
- {name: "Neq32F"},
- {name: "Neq64F"},
+ {name: "Neq8", argLength: 2, commutative: true}, // arg0 != arg1
+ {name: "Neq16", argLength: 2, commutative: true},
+ {name: "Neq32", argLength: 2, commutative: true},
+ {name: "Neq64", argLength: 2, commutative: true},
+ {name: "NeqPtr", argLength: 2, commutative: true},
+ {name: "NeqInter", argLength: 2}, // arg0 or arg1 is nil; other cases handled by frontend
+ {name: "NeqSlice", argLength: 2}, // arg0 or arg1 is nil; other cases handled by frontend
+ {name: "Neq32F", argLength: 2},
+ {name: "Neq64F", argLength: 2},
- {name: "Less8"}, // arg0 < arg1
- {name: "Less8U"},
- {name: "Less16"},
- {name: "Less16U"},
- {name: "Less32"},
- {name: "Less32U"},
- {name: "Less64"},
- {name: "Less64U"},
- {name: "Less32F"},
- {name: "Less64F"},
+ {name: "Less8", argLength: 2}, // arg0 < arg1
+ {name: "Less8U", argLength: 2},
+ {name: "Less16", argLength: 2},
+ {name: "Less16U", argLength: 2},
+ {name: "Less32", argLength: 2},
+ {name: "Less32U", argLength: 2},
+ {name: "Less64", argLength: 2},
+ {name: "Less64U", argLength: 2},
+ {name: "Less32F", argLength: 2},
+ {name: "Less64F", argLength: 2},
- {name: "Leq8"}, // arg0 <= arg1
- {name: "Leq8U"},
- {name: "Leq16"},
- {name: "Leq16U"},
- {name: "Leq32"},
- {name: "Leq32U"},
- {name: "Leq64"},
- {name: "Leq64U"},
- {name: "Leq32F"},
- {name: "Leq64F"},
+ {name: "Leq8", argLength: 2}, // arg0 <= arg1
+ {name: "Leq8U", argLength: 2},
+ {name: "Leq16", argLength: 2},
+ {name: "Leq16U", argLength: 2},
+ {name: "Leq32", argLength: 2},
+ {name: "Leq32U", argLength: 2},
+ {name: "Leq64", argLength: 2},
+ {name: "Leq64U", argLength: 2},
+ {name: "Leq32F", argLength: 2},
+ {name: "Leq64F", argLength: 2},
- {name: "Greater8"}, // arg0 > arg1
- {name: "Greater8U"},
- {name: "Greater16"},
- {name: "Greater16U"},
- {name: "Greater32"},
- {name: "Greater32U"},
- {name: "Greater64"},
- {name: "Greater64U"},
- {name: "Greater32F"},
- {name: "Greater64F"},
+ {name: "Greater8", argLength: 2}, // arg0 > arg1
+ {name: "Greater8U", argLength: 2},
+ {name: "Greater16", argLength: 2},
+ {name: "Greater16U", argLength: 2},
+ {name: "Greater32", argLength: 2},
+ {name: "Greater32U", argLength: 2},
+ {name: "Greater64", argLength: 2},
+ {name: "Greater64U", argLength: 2},
+ {name: "Greater32F", argLength: 2},
+ {name: "Greater64F", argLength: 2},
- {name: "Geq8"}, // arg0 <= arg1
- {name: "Geq8U"},
- {name: "Geq16"},
- {name: "Geq16U"},
- {name: "Geq32"},
- {name: "Geq32U"},
- {name: "Geq64"},
- {name: "Geq64U"},
- {name: "Geq32F"},
- {name: "Geq64F"},
+ {name: "Geq8", argLength: 2}, // arg0 <= arg1
+ {name: "Geq8U", argLength: 2},
+ {name: "Geq16", argLength: 2},
+ {name: "Geq16U", argLength: 2},
+ {name: "Geq32", argLength: 2},
+ {name: "Geq32U", argLength: 2},
+ {name: "Geq64", argLength: 2},
+ {name: "Geq64U", argLength: 2},
+ {name: "Geq32F", argLength: 2},
+ {name: "Geq64F", argLength: 2},
// 1-input ops
- {name: "Not"}, // !arg0
+ {name: "Not", argLength: 1}, // !arg0
- {name: "Neg8"}, // -arg0
- {name: "Neg16"},
- {name: "Neg32"},
- {name: "Neg64"},
- {name: "Neg32F"},
- {name: "Neg64F"},
+ {name: "Neg8", argLength: 1}, // -arg0
+ {name: "Neg16", argLength: 1},
+ {name: "Neg32", argLength: 1},
+ {name: "Neg64", argLength: 1},
+ {name: "Neg32F", argLength: 1},
+ {name: "Neg64F", argLength: 1},
- {name: "Com8"}, // ^arg0
- {name: "Com16"},
- {name: "Com32"},
- {name: "Com64"},
+ {name: "Com8", argLength: 1}, // ^arg0
+ {name: "Com16", argLength: 1},
+ {name: "Com32", argLength: 1},
+ {name: "Com64", argLength: 1},
- {name: "Sqrt"}, // sqrt(arg0), float64 only
+ {name: "Sqrt", argLength: 1}, // sqrt(arg0), float64 only
- // Data movement
- {name: "Phi", variableLength: true}, // select an argument based on which predecessor block we came from
- {name: "Copy"}, // output = arg0
+ // Data movement, max argument length for Phi is indefinite so just pick
+ // a really large number
+ {name: "Phi", argLength: -1}, // select an argument based on which predecessor block we came from
+ {name: "Copy", argLength: 1}, // output = arg0
// Convert converts between pointers and integers.
// We have a special op for this so as to not confuse GC
// (particularly stack maps). It takes a memory arg so it
// gets correctly ordered with respect to GC safepoints.
// arg0=ptr/int arg1=mem, output=int/ptr
- {name: "Convert"},
+ {name: "Convert", argLength: 2},
// constants. Constant values are stored in the aux or
// auxint fields.
@@ -271,108 +272,108 @@
// on whether it is a global or stack variable). The Aux field identifies the
// variable. It will be either an *ExternSymbol (with arg0=SB), *ArgSymbol (arg0=SP),
// or *AutoSymbol (arg0=SP).
- {name: "Addr", aux: "Sym"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable.
+ {name: "Addr", argLength: 1, aux: "Sym"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable.
{name: "SP"}, // stack pointer
{name: "SB", typ: "Uintptr"}, // static base pointer (a.k.a. globals pointer)
{name: "Func", aux: "Sym"}, // entry address of a function
// Memory operations
- {name: "Load"}, // Load from arg0. arg1=memory
- {name: "Store", typ: "Mem", aux: "Int64"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory.
- {name: "Move", aux: "Int64"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory.
- {name: "Zero", aux: "Int64"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory.
+ {name: "Load", argLength: 2}, // Load from arg0. arg1=memory
+ {name: "Store", argLength: 3, typ: "Mem", aux: "Int64"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory.
+ {name: "Move", argLength: 3, aux: "Int64"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory.
+ {name: "Zero", argLength: 2, aux: "Int64"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory.
// Function calls. Arguments to the call have already been written to the stack.
// Return values appear on the stack. The method receiver, if any, is treated
// as a phantom first argument.
- {name: "ClosureCall", aux: "Int64"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory.
- {name: "StaticCall", aux: "SymOff"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory.
- {name: "DeferCall", aux: "Int64"}, // defer call. arg0=memory, auxint=arg size. Returns memory.
- {name: "GoCall", aux: "Int64"}, // go call. arg0=memory, auxint=arg size. Returns memory.
- {name: "InterCall", aux: "Int64"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory.
+ {name: "ClosureCall", argLength: 3, aux: "Int64"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory.
+ {name: "StaticCall", argLength: 1, aux: "SymOff"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory.
+ {name: "DeferCall", argLength: 1, aux: "Int64"}, // defer call. arg0=memory, auxint=arg size. Returns memory.
+ {name: "GoCall", argLength: 1, aux: "Int64"}, // go call. arg0=memory, auxint=arg size. Returns memory.
+ {name: "InterCall", argLength: 2, aux: "Int64"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory.
// Conversions: signed extensions, zero (unsigned) extensions, truncations
- {name: "SignExt8to16", typ: "Int16"},
- {name: "SignExt8to32"},
- {name: "SignExt8to64"},
- {name: "SignExt16to32"},
- {name: "SignExt16to64"},
- {name: "SignExt32to64"},
- {name: "ZeroExt8to16", typ: "UInt16"},
- {name: "ZeroExt8to32"},
- {name: "ZeroExt8to64"},
- {name: "ZeroExt16to32"},
- {name: "ZeroExt16to64"},
- {name: "ZeroExt32to64"},
- {name: "Trunc16to8"},
- {name: "Trunc32to8"},
- {name: "Trunc32to16"},
- {name: "Trunc64to8"},
- {name: "Trunc64to16"},
- {name: "Trunc64to32"},
+ {name: "SignExt8to16", argLength: 1, typ: "Int16"},
+ {name: "SignExt8to32", argLength: 1},
+ {name: "SignExt8to64", argLength: 1},
+ {name: "SignExt16to32", argLength: 1},
+ {name: "SignExt16to64", argLength: 1},
+ {name: "SignExt32to64", argLength: 1},
+ {name: "ZeroExt8to16", argLength: 1, typ: "UInt16"},
+ {name: "ZeroExt8to32", argLength: 1},
+ {name: "ZeroExt8to64", argLength: 1},
+ {name: "ZeroExt16to32", argLength: 1},
+ {name: "ZeroExt16to64", argLength: 1},
+ {name: "ZeroExt32to64", argLength: 1},
+ {name: "Trunc16to8", argLength: 1},
+ {name: "Trunc32to8", argLength: 1},
+ {name: "Trunc32to16", argLength: 1},
+ {name: "Trunc64to8", argLength: 1},
+ {name: "Trunc64to16", argLength: 1},
+ {name: "Trunc64to32", argLength: 1},
- {name: "Cvt32to32F"},
- {name: "Cvt32to64F"},
- {name: "Cvt64to32F"},
- {name: "Cvt64to64F"},
- {name: "Cvt32Fto32"},
- {name: "Cvt32Fto64"},
- {name: "Cvt64Fto32"},
- {name: "Cvt64Fto64"},
- {name: "Cvt32Fto64F"},
- {name: "Cvt64Fto32F"},
+ {name: "Cvt32to32F", argLength: 1},
+ {name: "Cvt32to64F", argLength: 1},
+ {name: "Cvt64to32F", argLength: 1},
+ {name: "Cvt64to64F", argLength: 1},
+ {name: "Cvt32Fto32", argLength: 1},
+ {name: "Cvt32Fto64", argLength: 1},
+ {name: "Cvt64Fto32", argLength: 1},
+ {name: "Cvt64Fto64", argLength: 1},
+ {name: "Cvt32Fto64F", argLength: 1},
+ {name: "Cvt64Fto32F", argLength: 1},
// Automatically inserted safety checks
- {name: "IsNonNil", typ: "Bool"}, // arg0 != nil
- {name: "IsInBounds", typ: "Bool"}, // 0 <= arg0 < arg1
- {name: "IsSliceInBounds", typ: "Bool"}, // 0 <= arg0 <= arg1
- {name: "NilCheck", typ: "Void"}, // arg0=ptr, arg1=mem. Panics if arg0 is nil, returns void.
+ {name: "IsNonNil", argLength: 1, typ: "Bool"}, // arg0 != nil
+ {name: "IsInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 < arg1
+ {name: "IsSliceInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 <= arg1
+ {name: "NilCheck", argLength: 2, typ: "Void"}, // arg0=ptr, arg1=mem. Panics if arg0 is nil, returns void.
// Pseudo-ops
- {name: "GetG"}, // runtime.getg() (read g pointer). arg0=mem
- {name: "GetClosurePtr"}, // get closure pointer from dedicated register
+ {name: "GetG", argLength: 1}, // runtime.getg() (read g pointer). arg0=mem
+ {name: "GetClosurePtr"}, // get closure pointer from dedicated register
// Indexing operations
- {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i]
- {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type
- {name: "OffPtr", aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers)
+ {name: "ArrayIndex", argLength: 2}, // arg0=array, arg1=index. Returns a[i]
+ {name: "PtrIndex", argLength: 2}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type
+ {name: "OffPtr", argLength: 1, aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers)
// Slices
- {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap
- {name: "SlicePtr", typ: "BytePtr"}, // ptr(arg0)
- {name: "SliceLen"}, // len(arg0)
- {name: "SliceCap"}, // cap(arg0)
+ {name: "SliceMake", argLength: 3}, // arg0=ptr, arg1=len, arg2=cap
+ {name: "SlicePtr", argLength: 1, typ: "BytePtr"}, // ptr(arg0)
+ {name: "SliceLen", argLength: 1}, // len(arg0)
+ {name: "SliceCap", argLength: 1}, // cap(arg0)
// Complex (part/whole)
- {name: "ComplexMake"}, // arg0=real, arg1=imag
- {name: "ComplexReal"}, // real(arg0)
- {name: "ComplexImag"}, // imag(arg0)
+ {name: "ComplexMake", argLength: 2}, // arg0=real, arg1=imag
+ {name: "ComplexReal", argLength: 1}, // real(arg0)
+ {name: "ComplexImag", argLength: 1}, // imag(arg0)
// Strings
- {name: "StringMake"}, // arg0=ptr, arg1=len
- {name: "StringPtr"}, // ptr(arg0)
- {name: "StringLen"}, // len(arg0)
+ {name: "StringMake", argLength: 2}, // arg0=ptr, arg1=len
+ {name: "StringPtr", argLength: 1}, // ptr(arg0)
+ {name: "StringLen", argLength: 1}, // len(arg0)
// Interfaces
- {name: "IMake"}, // arg0=itab, arg1=data
- {name: "ITab", typ: "BytePtr"}, // arg0=interface, returns itable field
- {name: "IData"}, // arg0=interface, returns data field
+ {name: "IMake", argLength: 2}, // arg0=itab, arg1=data
+ {name: "ITab", argLength: 1, typ: "BytePtr"}, // arg0=interface, returns itable field
+ {name: "IData", argLength: 1}, // arg0=interface, returns data field
// Structs
- {name: "StructMake0"}, // Returns struct with 0 fields.
- {name: "StructMake1"}, // arg0=field0. Returns struct.
- {name: "StructMake2"}, // arg0,arg1=field0,field1. Returns struct.
- {name: "StructMake3"}, // arg0..2=field0..2. Returns struct.
- {name: "StructMake4"}, // arg0..3=field0..3. Returns struct.
- {name: "StructSelect", aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field.
+ {name: "StructMake0"}, // Returns struct with 0 fields.
+ {name: "StructMake1", argLength: 1}, // arg0=field0. Returns struct.
+ {name: "StructMake2", argLength: 2}, // arg0,arg1=field0,field1. Returns struct.
+ {name: "StructMake3", argLength: 3}, // arg0..2=field0..2. Returns struct.
+ {name: "StructMake4", argLength: 4}, // arg0..3=field0..3. Returns struct.
+ {name: "StructSelect", argLength: 1, aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field.
// Spill&restore ops for the register allocator. These are
// semantically identical to OpCopy; they do not take/return
// stores like regular memory ops do. We can get away without memory
// args because we know there is no aliasing of spill slots on the stack.
- {name: "StoreReg"},
- {name: "LoadReg"},
+ {name: "StoreReg", argLength: 1},
+ {name: "LoadReg", argLength: 1},
// Used during ssa construction. Like Copy, but the arg has not been specified yet.
{name: "FwdRef"},
@@ -380,9 +381,9 @@
// Unknown value. Used for Values whose values don't matter because they are dead code.
{name: "Unknown"},
- {name: "VarDef", aux: "Sym", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem
- {name: "VarKill", aux: "Sym"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem
- {name: "VarLive", aux: "Sym"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem
+ {name: "VarDef", argLength: 1, aux: "Sym", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem
+ {name: "VarKill", argLength: 1, aux: "Sym"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem
+ {name: "VarLive", argLength: 1, aux: "Sym"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem
}
// kind control successors implicit exit
