Merge branch 'dev.ssa' into mergebranch
Merge dev.ssa branch back into master.
Change-Id: Ie6fac3f8d355ab164f934415fe4fc7fcb8c3db16
diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index ecf52c5..bc6a495 100644
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -127,6 +127,9 @@
{"(SI)(BX*1)", "(SI)(BX*1)"},
{"(SI)(DX*1)", "(SI)(DX*1)"},
{"(SP)", "(SP)"},
+ {"(SP)(AX*4)", "(SP)(AX*4)"},
+ {"32(SP)(BX*2)", "32(SP)(BX*2)"},
+ {"32323(SP)(R8*4)", "32323(SP)(R8*4)"},
{"+3(PC)", "3(PC)"},
{"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
{"-3(PC)", "-3(PC)"},
diff --git a/src/cmd/asm/internal/asm/testdata/amd64.s b/src/cmd/asm/internal/asm/testdata/amd64.s
index 70e7636..1411165 100644
--- a/src/cmd/asm/internal/asm/testdata/amd64.s
+++ b/src/cmd/asm/internal/asm/testdata/amd64.s
@@ -127,5 +127,19 @@
MOVNTDQ X1, (AX) // MOVNTO X1, (AX)
MOVOA (AX), X1 // MOVO (AX), X1
+// Tests for SP indexed addresses.
+ MOVQ foo(SP)(AX*1), BX // 488b1c04
+ MOVQ foo+32(SP)(CX*2), DX // 488b544c20
+ MOVQ foo+32323(SP)(R8*4), R9 // 4e8b8c84437e0000
+ MOVL foo(SP)(SI*8), DI // 8b3cf4
+ MOVL foo+32(SP)(R10*1), R11 // 468b5c1420
+ MOVL foo+32323(SP)(R12*2), R13 // 468bac64437e0000
+ MOVW foo(SP)(AX*4), R8 // 66448b0484
+ MOVW foo+32(SP)(R9*8), CX // 66428b4ccc20
+ MOVW foo+32323(SP)(AX*1), DX // 668b9404437e0000
+ MOVB foo(SP)(AX*2), AL // 8a0444
+ MOVB foo+32(SP)(CX*4), AH // 8a648c20
+ MOVB foo+32323(SP)(CX*8), R9 // 448a8ccc437e0000
+
// LTYPE0 nonnon { outcode($1, &$2); }
RET // c3
diff --git a/src/cmd/asm/internal/asm/testdata/amd64error.s b/src/cmd/asm/internal/asm/testdata/amd64error.s
index 9895b54..81ca11b 100644
--- a/src/cmd/asm/internal/asm/testdata/amd64error.s
+++ b/src/cmd/asm/internal/asm/testdata/amd64error.s
@@ -3,5 +3,6 @@
// license that can be found in the LICENSE file.
TEXT errors(SB),$0
- MOVL foo<>(SB)(AX), AX // ERROR "invalid instruction"
+ MOVL foo<>(SB)(AX), AX // ERROR "invalid instruction"
+ MOVL (AX)(SP*1), AX // ERROR "invalid instruction"
RET
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index aafe6a8..02b0057 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -458,6 +458,7 @@
}
fmt.Fprint(fgo2, "\n")
+ fmt.Fprint(fgo2, "//go:cgo_unsafe_args\n")
conf.Fprint(fgo2, fset, d)
fmt.Fprint(fgo2, " {\n")
diff --git a/src/cmd/compile/internal/amd64/prog.go b/src/cmd/compile/internal/amd64/prog.go
index b3724b4..b43dde6 100644
--- a/src/cmd/compile/internal/amd64/prog.go
+++ b/src/cmd/compile/internal/amd64/prog.go
@@ -117,6 +117,7 @@
x86.AJPL: {Flags: gc.Cjmp | gc.UseCarry},
x86.AJPS: {Flags: gc.Cjmp | gc.UseCarry},
obj.AJMP: {Flags: gc.Jump | gc.Break | gc.KillCarry},
+ x86.ALEAW: {Flags: gc.LeftAddr | gc.RightWrite},
x86.ALEAL: {Flags: gc.LeftAddr | gc.RightWrite},
x86.ALEAQ: {Flags: gc.LeftAddr | gc.RightWrite},
x86.AMOVBLSX: {Flags: gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv},
@@ -167,6 +168,7 @@
x86.AORW: {Flags: gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry},
x86.APOPQ: {Flags: gc.SizeQ | gc.RightWrite},
x86.APUSHQ: {Flags: gc.SizeQ | gc.LeftRead},
+ x86.APXOR: {Flags: gc.SizeD | gc.LeftRead | RightRdwr},
x86.ARCLB: {Flags: gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
x86.ARCLL: {Flags: gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
x86.ARCLQ: {Flags: gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index d8ec059..a33ddeb 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -588,6 +588,7 @@
ptr.Ullman = 1
ptr.Used = true
ptr.Name.Curfn = xfunc
+ ptr.Xoffset = 0
xfunc.Func.Dcl = append(xfunc.Func.Dcl, ptr)
var body []*Node
if Isptr[rcvrtype.Etype] || Isinter(rcvrtype) {
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 39b74f6..8864b57 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -403,6 +403,7 @@
TFORW: "FORW",
TFIELD: "FIELD",
TSTRING: "STRING",
+ TUNSAFEPTR: "TUNSAFEPTR",
TANY: "ANY",
}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 2292a56..c151ca3 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -142,6 +142,8 @@
return lab
}
+// There is a copy of checkgoto in the new SSA backend.
+// Please keep them in sync.
func checkgoto(from *Node, to *Node) {
if from.Sym == to.Sym {
return
@@ -840,7 +842,7 @@
cgen_dcl(n.Left)
case OAS:
- if gen_as_init(n) {
+ if gen_as_init(n, false) {
break
}
Cgen_as(n.Left, n.Right)
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index ce3ad00..263d6d4 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -131,7 +131,7 @@
Note *string // literal string annotation
// TARRAY
- Bound int64 // negative is dynamic array
+ Bound int64 // negative is slice
// TMAP
Bucket *Type // internal type representing a hash bucket
@@ -759,4 +759,13 @@
var panicslice *Node
+var panicdivide *Node
+
var throwreturn *Node
+
+var growslice *Node
+
+var writebarrierptr *Node
+var typedmemmove *Node
+
+var panicdottype *Node
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f5d7a8d..73f71dd 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -530,6 +530,16 @@
return pl
}
+// nodarg does something that depends on the value of
+// fp (this was previously completely undocumented).
+//
+// fp=1 corresponds to input args
+// fp=0 corresponds to output args
+// fp=-1 is a special case of output args for a
+// specific call from walk that previously (and
+// incorrectly) passed a 1; the behavior is exactly
+// the same as it is for 1, except that PARAMOUT is
+// generated instead of PARAM.
func nodarg(t *Type, fp int) *Node {
var n *Node
@@ -555,7 +565,7 @@
Fatalf("nodarg: not field %v", t)
}
- if fp == 1 {
+ if fp == 1 || fp == -1 {
for _, n := range Curfn.Func.Dcl {
if (n.Class == PPARAM || n.Class == PPARAMOUT) && !isblanksym(t.Sym) && n.Sym == t.Sym {
return n
@@ -592,6 +602,9 @@
case 1: // input arg
n.Class = PPARAM
+ case -1: // output arg from paramstoheap
+ n.Class = PPARAMOUT
+
case 2: // offset output arg
Fatalf("shouldn't be used")
}
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index d7db786..acfa19b 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -33,10 +33,10 @@
// hand-craft the following initialization code
// var initdone· uint8 (1)
// func init() (2)
-// if initdone· != 0 { (3)
-// if initdone· == 2 (4)
-// return
-// throw(); (5)
+// if initdone· > 1 { (3)
+// return (3a)
+// if initdone· == 1 { (4)
+// throw(); (4a)
// }
// initdone· = 1; (6)
// // over all matching imported symbols
@@ -118,22 +118,21 @@
// (3)
a := Nod(OIF, nil, nil)
-
- a.Left = Nod(ONE, gatevar, Nodintconst(0))
+ a.Left = Nod(OGT, gatevar, Nodintconst(1))
+ a.Likely = 1
r = append(r, a)
+ // (3a)
+ a.Nbody.Set([]*Node{Nod(ORETURN, nil, nil)})
// (4)
b := Nod(OIF, nil, nil)
-
- b.Left = Nod(OEQ, gatevar, Nodintconst(2))
- b.Nbody.Set([]*Node{Nod(ORETURN, nil, nil)})
- a.Nbody.Set([]*Node{b})
-
- // (5)
- b = syslook("throwinit", 0)
-
- b = Nod(OCALL, b, nil)
- a.Nbody.Append(b)
+ b.Left = Nod(OEQ, gatevar, Nodintconst(1))
+ // this actually isn't likely, but code layout is better
+ // like this: no JMP needed after the call.
+ b.Likely = 1
+ r = append(r, b)
+ // (4a)
+ b.Nbody.Set([]*Node{Nod(OCALL, syslook("throwinit", 0), nil)})
// (6)
a = Nod(OAS, gatevar, Nodintconst(1))
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index d05ef27..bb8bfdf 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -7,6 +7,7 @@
package gc
import (
+ "cmd/compile/internal/ssa"
"cmd/internal/obj"
"flag"
"fmt"
@@ -286,6 +287,23 @@
}
}
}
+ // special case for ssa for now
+ if strings.HasPrefix(name, "ssa/") {
+ // expect form ssa/phase/flag
+ // e.g. -d=ssa/generic_cse/time
+ // _ in phase name also matches space
+ phase := name[4:]
+ flag := "debug" // default flag is debug
+ if i := strings.Index(phase, "/"); i >= 0 {
+ flag = phase[i+1:]
+ phase = phase[:i]
+ }
+ err := ssa.PhaseOption(phase, flag, val)
+ if err != "" {
+ log.Fatalf(err)
+ }
+ continue Split
+ }
log.Fatalf("unknown debug key -d %s\n", name)
}
}
@@ -844,7 +862,7 @@
return s
}
-type Pragma uint8
+type Pragma uint16
const (
Nointerface Pragma = 1 << iota
@@ -855,6 +873,7 @@
Systemstack // func must run on system stack
Nowritebarrier // emit compiler error instead of write barrier
Nowritebarrierrec // error on write barrier in this or recursive callees
+ CgoUnsafeArgs // treat a pointer to one arg as a pointer to them all
)
type lexer struct {
@@ -1677,6 +1696,8 @@
Yyerror("//go:nowritebarrierrec only allowed in runtime")
}
l.pragma |= Nowritebarrierrec | Nowritebarrier // implies Nowritebarrier
+ case "go:cgo_unsafe_args":
+ l.pragma |= CgoUnsafeArgs
}
return c
}
diff --git a/src/cmd/compile/internal/gc/opnames.go b/src/cmd/compile/internal/gc/opnames.go
index 0609643..df0d8cb 100644
--- a/src/cmd/compile/internal/gc/opnames.go
+++ b/src/cmd/compile/internal/gc/opnames.go
@@ -160,5 +160,9 @@
OLROT: "LROT",
ORROTC: "RROTC",
ORETJMP: "RETJMP",
+ OPS: "OPS",
+ OPC: "OPC",
+ OSQRT: "OSQRT",
+ OGETG: "OGETG",
OEND: "END",
}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index e94ff21..94bc633 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -230,6 +230,7 @@
n := order.temp[i]
if n.Name.Keepalive {
n.Name.Keepalive = false
+ n.Addrtaken = true // ensure SSA keeps the n variable
kill = Nod(OVARLIVE, n, nil)
typecheck(&kill, Etop)
*out = append(*out, kill)
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 31cc3bc..41038d3 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -5,6 +5,7 @@
package gc
import (
+ "cmd/compile/internal/ssa"
"cmd/internal/obj"
"crypto/md5"
"fmt"
@@ -341,7 +342,12 @@
Deferreturn = Sysfunc("deferreturn")
Panicindex = Sysfunc("panicindex")
panicslice = Sysfunc("panicslice")
+ panicdivide = Sysfunc("panicdivide")
throwreturn = Sysfunc("throwreturn")
+ growslice = Sysfunc("growslice")
+ writebarrierptr = Sysfunc("writebarrierptr")
+ typedmemmove = Sysfunc("typedmemmove")
+ panicdottype = Sysfunc("panicdottype")
}
lno := setlineno(fn)
@@ -358,6 +364,7 @@
var nam *Node
var gcargs *Sym
var gclocals *Sym
+ var ssafn *ssa.Func
if len(fn.Nbody.Slice()) == 0 {
if pure_go != 0 || strings.HasPrefix(fn.Func.Nname.Sym.Name, "init.") {
Yyerror("missing function body for %q", fn.Func.Nname.Sym.Name)
@@ -409,6 +416,11 @@
goto ret
}
+ // Build an SSA backend function.
+ if shouldssa(Curfn) {
+ ssafn = buildssa(Curfn)
+ }
+
continpc = nil
breakpc = nil
@@ -471,6 +483,14 @@
}
}
+ if ssafn != nil {
+ genssa(ssafn, ptxt, gcargs, gclocals)
+ if Curfn.Func.Endlineno != 0 {
+ lineno = Curfn.Func.Endlineno
+ }
+ ssafn.Free()
+ return
+ }
Genslice(Curfn.Func.Enter.Slice())
Genslice(Curfn.Nbody.Slice())
gclean()
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 84a24a8..78872c1 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -19,6 +19,7 @@
"cmd/internal/obj"
"fmt"
"sort"
+ "strings"
)
const (
@@ -410,7 +411,7 @@
bb := newblock(firstp)
cfg = append(cfg, bb)
- for p := firstp; p != nil; p = p.Link {
+ for p := firstp; p != nil && p.As != obj.AEND; p = p.Link {
Thearch.Proginfo(p)
if p.To.Type == obj.TYPE_BRANCH {
if p.To.Val == nil {
@@ -438,7 +439,7 @@
// contained instructions until a label is reached. Add edges
// for branches and fall-through instructions.
for _, bb := range cfg {
- for p := bb.last; p != nil; p = p.Link {
+ for p := bb.last; p != nil && p.As != obj.AEND; p = p.Link {
if p.Opt != nil && p != bb.last {
break
}
@@ -447,6 +448,8 @@
// Stop before an unreachable RET, to avoid creating
// unreachable control flow nodes.
if p.Link != nil && p.Link.As == obj.ARET && p.Link.Mode == 1 {
+ // TODO: remove after SSA is done. SSA does not
+ // generate any unreachable RET instructions.
break
}
@@ -1364,7 +1367,7 @@
}
n = lv.vars[j]
if n.Class != PPARAM {
- yyerrorl(int(p.Lineno), "internal error: %v %v recorded as live on entry", Curfn.Func.Nname, Nconv(n, obj.FmtLong))
+ yyerrorl(int(p.Lineno), "internal error: %v %v recorded as live on entry, p.Pc=%v", Curfn.Func.Nname, Nconv(n, obj.FmtLong), p.Pc)
}
}
}
@@ -1389,8 +1392,13 @@
if msg != nil {
fmt_ = ""
fmt_ += fmt.Sprintf("%v: live at ", p.Line())
- if p.As == obj.ACALL && p.To.Node != nil {
- fmt_ += fmt.Sprintf("call to %s:", ((p.To.Node).(*Node)).Sym.Name)
+ if p.As == obj.ACALL && p.To.Sym != nil {
+ name := p.To.Sym.Name
+ i := strings.Index(name, ".")
+ if i >= 0 {
+ name = name[i+1:]
+ }
+ fmt_ += fmt.Sprintf("call to %s:", name)
} else if p.As == obj.ACALL {
fmt_ += "indirect call:"
} else {
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 352a399..376928f 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -13,7 +13,7 @@
//
// For flag_race it modifies the function as follows:
//
-// 1. It inserts a call to racefuncenter at the beginning of each function.
+// 1. It inserts a call to racefuncenterfp at the beginning of each function.
// 2. It inserts a call to racefuncexit at the end of each function.
// 3. It inserts a call to raceread before each memory read.
// 4. It inserts a call to racewrite before each memory write.
@@ -33,7 +33,7 @@
// at best instrumentation would cause infinite recursion.
var omit_pkgs = []string{"runtime/internal/atomic", "runtime/internal/sys", "runtime", "runtime/race", "runtime/msan"}
-// Only insert racefuncenter/racefuncexit into the following packages.
+// Only insert racefuncenterfp/racefuncexit into the following packages.
// Memory accesses in the packages are either uninteresting or will cause false positives.
var norace_inst_pkgs = []string{"sync", "sync/atomic"}
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index b3f6b6a..43c6db0 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -55,8 +55,7 @@
func makefield(name string, t *Type) *Type {
f := typ(TFIELD)
f.Type = t
- f.Sym = new(Sym)
- f.Sym.Name = name
+ f.Sym = nopkg.Lookup(name)
return f
}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 12bdfba..bee045f 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -1209,6 +1209,7 @@
return -1
}
+// stataddr sets nam to the static address of n and reports whether it succeeeded.
func stataddr(nam *Node, n *Node) bool {
if n == nil {
return false
@@ -1376,7 +1377,9 @@
return &p.E[len(p.E)-1]
}
-func gen_as_init(n *Node) bool {
+// gen_as_init attempts to emit static data for n and reports whether it succeeded.
+// If reportOnly is true, it does not emit static data and does not modify the AST.
+func gen_as_init(n *Node, reportOnly bool) bool {
var nr *Node
var nl *Node
var nam Node
@@ -1425,7 +1428,6 @@
case OSLICEARR:
if nr.Right.Op == OKEY && nr.Right.Left == nil && nr.Right.Right == nil {
nr = nr.Left
- gused(nil) // in case the data is the dest of a goto
nl := nr
if nr == nil || nr.Op != OADDR {
goto no
@@ -1440,16 +1442,18 @@
goto no
}
- nam.Xoffset += int64(Array_array)
- gdata(&nam, nl, int(Types[Tptr].Width))
+ if !reportOnly {
+ nam.Xoffset += int64(Array_array)
+ gdata(&nam, nl, int(Types[Tptr].Width))
- nam.Xoffset += int64(Array_nel) - int64(Array_array)
- var nod1 Node
- Nodconst(&nod1, Types[TINT], nr.Type.Bound)
- gdata(&nam, &nod1, Widthint)
+ nam.Xoffset += int64(Array_nel) - int64(Array_array)
+ var nod1 Node
+ Nodconst(&nod1, Types[TINT], nr.Type.Bound)
+ gdata(&nam, &nod1, Widthint)
- nam.Xoffset += int64(Array_cap) - int64(Array_nel)
- gdata(&nam, &nod1, Widthint)
+ nam.Xoffset += int64(Array_cap) - int64(Array_nel)
+ gdata(&nam, &nod1, Widthint)
+ }
return true
}
@@ -1480,13 +1484,19 @@
TPTR64,
TFLOAT32,
TFLOAT64:
- gdata(&nam, nr, int(nr.Type.Width))
+ if !reportOnly {
+ gdata(&nam, nr, int(nr.Type.Width))
+ }
case TCOMPLEX64, TCOMPLEX128:
- gdatacomplex(&nam, nr.Val().U.(*Mpcplx))
+ if !reportOnly {
+ gdatacomplex(&nam, nr.Val().U.(*Mpcplx))
+ }
case TSTRING:
- gdatastring(&nam, nr.Val().U.(string))
+ if !reportOnly {
+ gdatastring(&nam, nr.Val().U.(string))
+ }
}
return true
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
new file mode 100644
index 0000000..6bf0861
--- /dev/null
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -0,0 +1,5235 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gc
+
+import (
+ "bytes"
+ "fmt"
+ "html"
+ "math"
+ "os"
+ "strings"
+
+ "cmd/compile/internal/ssa"
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+)
+
+// Smallest possible faulting page at address zero.
+const minZeroPage = 4096
+
+var ssaConfig *ssa.Config
+var ssaExp ssaExport
+
+func initssa() *ssa.Config {
+ ssaExp.unimplemented = false
+ ssaExp.mustImplement = true
+ if ssaConfig == nil {
+ ssaConfig = ssa.NewConfig(Thearch.Thestring, &ssaExp, Ctxt, Debug['N'] == 0)
+ }
+ return ssaConfig
+}
+
+func shouldssa(fn *Node) bool {
+ if Thearch.Thestring != "amd64" {
+ return false
+ }
+
+ // Environment variable control of SSA CG
+ // 1. IF GOSSAFUNC == current function name THEN
+ // compile this function with SSA and log output to ssa.html
+
+ // 2. IF GOSSAHASH == "" THEN
+ // compile this function (and everything else) with SSA
+
+ // 3. IF GOSSAHASH == "n" or "N"
+ // IF GOSSAPKG == current package name THEN
+ // compile this function (and everything in this package) with SSA
+ // ELSE
+ // use the old back end for this function.
+ // This is for compatibility with existing test harness and should go away.
+
+ // 4. IF GOSSAHASH is a suffix of the binary-rendered SHA1 hash of the function name THEN
+ // compile this function with SSA
+ // ELSE
+ // compile this function with the old back end.
+
+ // Plan is for 3 to be removed when the tests are revised.
+ // SSA is now default, and is disabled by setting
+ // GOSSAHASH to n or N, or selectively with strings of
+ // 0 and 1.
+
+ name := fn.Func.Nname.Sym.Name
+
+ funcname := os.Getenv("GOSSAFUNC")
+ if funcname != "" {
+ // If GOSSAFUNC is set, compile only that function.
+ return name == funcname
+ }
+
+ pkg := os.Getenv("GOSSAPKG")
+ if pkg != "" {
+ // If GOSSAPKG is set, compile only that package.
+ return localpkg.Name == pkg
+ }
+
+ return initssa().DebugHashMatch("GOSSAHASH", name)
+}
+
+// buildssa builds an SSA function.
+func buildssa(fn *Node) *ssa.Func {
+ name := fn.Func.Nname.Sym.Name
+ printssa := strings.HasSuffix(name, "_ssa") || strings.Contains(name, "_ssa.") || name == os.Getenv("GOSSAFUNC")
+ if printssa {
+ fmt.Println("generating SSA for", name)
+ dumpslice("buildssa-enter", fn.Func.Enter.Slice())
+ dumpslice("buildssa-body", fn.Nbody.Slice())
+ dumpslice("buildssa-exit", fn.Func.Exit.Slice())
+ }
+
+ var s state
+ s.pushLine(fn.Lineno)
+ defer s.popLine()
+
+ if fn.Func.Pragma&CgoUnsafeArgs != 0 {
+ s.cgoUnsafeArgs = true
+ }
+ // TODO(khr): build config just once at the start of the compiler binary
+
+ ssaExp.log = printssa
+
+ s.config = initssa()
+ s.f = s.config.NewFunc()
+ s.f.Name = name
+ s.exitCode = fn.Func.Exit
+ s.panics = map[funcLine]*ssa.Block{}
+
+ if name == os.Getenv("GOSSAFUNC") {
+ // TODO: tempfile? it is handy to have the location
+ // of this file be stable, so you can just reload in the browser.
+ s.config.HTML = ssa.NewHTMLWriter("ssa.html", s.config, name)
+ // TODO: generate and print a mapping from nodes to values and blocks
+ }
+ defer func() {
+ if !printssa {
+ s.config.HTML.Close()
+ }
+ }()
+
+ // Allocate starting block
+ s.f.Entry = s.f.NewBlock(ssa.BlockPlain)
+
+ // Allocate starting values
+ s.labels = map[string]*ssaLabel{}
+ s.labeledNodes = map[*Node]*ssaLabel{}
+ s.startmem = s.entryNewValue0(ssa.OpInitMem, ssa.TypeMem)
+ s.sp = s.entryNewValue0(ssa.OpSP, Types[TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
+ s.sb = s.entryNewValue0(ssa.OpSB, Types[TUINTPTR])
+
+ s.startBlock(s.f.Entry)
+ s.vars[&memVar] = s.startmem
+
+ s.varsyms = map[*Node]interface{}{}
+
+ // Generate addresses of local declarations
+ s.decladdrs = map[*Node]*ssa.Value{}
+ for _, n := range fn.Func.Dcl {
+ switch n.Class {
+ case PPARAM, PPARAMOUT:
+ aux := s.lookupSymbol(n, &ssa.ArgSymbol{Typ: n.Type, Node: n})
+ s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp)
+ if n.Class == PPARAMOUT && s.canSSA(n) {
+ // Save ssa-able PPARAMOUT variables so we can
+ // store them back to the stack at the end of
+ // the function.
+ s.returns = append(s.returns, n)
+ }
+ case PAUTO | PHEAP:
+ // TODO this looks wrong for PAUTO|PHEAP, no vardef, but also no definition
+ aux := s.lookupSymbol(n, &ssa.AutoSymbol{Typ: n.Type, Node: n})
+ s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp)
+ case PPARAM | PHEAP, PPARAMOUT | PHEAP:
+ // This ends up wrong, have to do it at the PARAM node instead.
+ case PAUTO:
+ // processed at each use, to prevent Addr coming
+ // before the decl.
+ case PFUNC:
+ // local function - already handled by frontend
+ default:
+ str := ""
+ if n.Class&PHEAP != 0 {
+ str = ",heap"
+ }
+ s.Unimplementedf("local variable with class %s%s unimplemented", classnames[n.Class&^PHEAP], str)
+ }
+ }
+
+ // Convert the AST-based IR to the SSA-based IR
+ s.stmts(fn.Func.Enter)
+ s.stmts(fn.Nbody)
+
+ // fallthrough to exit
+ if s.curBlock != nil {
+ s.stmts(s.exitCode)
+ m := s.mem()
+ b := s.endBlock()
+ b.Kind = ssa.BlockRet
+ b.Control = m
+ }
+
+ // Check that we used all labels
+ for name, lab := range s.labels {
+ if !lab.used() && !lab.reported {
+ yyerrorl(int(lab.defNode.Lineno), "label %v defined and not used", name)
+ lab.reported = true
+ }
+ if lab.used() && !lab.defined() && !lab.reported {
+ yyerrorl(int(lab.useNode.Lineno), "label %v not defined", name)
+ lab.reported = true
+ }
+ }
+
+ // Check any forward gotos. Non-forward gotos have already been checked.
+ for _, n := range s.fwdGotos {
+ lab := s.labels[n.Left.Sym.Name]
+ // If the label is undefined, we have already have printed an error.
+ if lab.defined() {
+ s.checkgoto(n, lab.defNode)
+ }
+ }
+
+ if nerrors > 0 {
+ s.f.Free()
+ return nil
+ }
+
+ // Link up variable uses to variable definitions
+ s.linkForwardReferences()
+
+ // Don't carry reference this around longer than necessary
+ s.exitCode = Nodes{}
+
+ // Main call to ssa package to compile function
+ ssa.Compile(s.f)
+
+ return s.f
+}
+
+type state struct {
+ // configuration (arch) information
+ config *ssa.Config
+
+ // function we're building
+ f *ssa.Func
+
+ // labels and labeled control flow nodes (OFOR, OSWITCH, OSELECT) in f
+ labels map[string]*ssaLabel
+ labeledNodes map[*Node]*ssaLabel
+
+ // gotos that jump forward; required for deferred checkgoto calls
+ fwdGotos []*Node
+ // Code that must precede any return
+ // (e.g., copying value of heap-escaped paramout back to true paramout)
+ exitCode Nodes
+
+ // unlabeled break and continue statement tracking
+ breakTo *ssa.Block // current target for plain break statement
+ continueTo *ssa.Block // current target for plain continue statement
+
+ // current location where we're interpreting the AST
+ curBlock *ssa.Block
+
+ // variable assignments in the current block (map from variable symbol to ssa value)
+ // *Node is the unique identifier (an ONAME Node) for the variable.
+ vars map[*Node]*ssa.Value
+
+ // all defined variables at the end of each block. Indexed by block ID.
+ defvars []map[*Node]*ssa.Value
+
+ // addresses of PPARAM and PPARAMOUT variables.
+ decladdrs map[*Node]*ssa.Value
+
+ // symbols for PEXTERN, PAUTO and PPARAMOUT variables so they can be reused.
+ varsyms map[*Node]interface{}
+
+ // starting values. Memory, stack pointer, and globals pointer
+ startmem *ssa.Value
+ sp *ssa.Value
+ sb *ssa.Value
+
+ // line number stack. The current line number is top of stack
+ line []int32
+
+ // list of panic calls by function name and line number.
+ // Used to deduplicate panic calls.
+ panics map[funcLine]*ssa.Block
+
+ // list of FwdRef values.
+ fwdRefs []*ssa.Value
+
+ // list of PPARAMOUT (return) variables. Does not include PPARAM|PHEAP vars.
+ returns []*Node
+
+ cgoUnsafeArgs bool
+}
+
+type funcLine struct {
+ f *Node
+ line int32
+}
+
+type ssaLabel struct {
+ target *ssa.Block // block identified by this label
+ breakTarget *ssa.Block // block to break to in control flow node identified by this label
+ continueTarget *ssa.Block // block to continue to in control flow node identified by this label
+ defNode *Node // label definition Node (OLABEL)
+ // Label use Node (OGOTO, OBREAK, OCONTINUE).
+ // Used only for error detection and reporting.
+ // There might be multiple uses, but we only need to track one.
+ useNode *Node
+ reported bool // reported indicates whether an error has already been reported for this label
+}
+
+// defined reports whether the label has a definition (OLABEL node).
+func (l *ssaLabel) defined() bool { return l.defNode != nil }
+
+// used reports whether the label has a use (OGOTO, OBREAK, or OCONTINUE node).
+func (l *ssaLabel) used() bool { return l.useNode != nil }
+
+// label returns the label associated with sym, creating it if necessary.
+func (s *state) label(sym *Sym) *ssaLabel {
+ lab := s.labels[sym.Name]
+ if lab == nil {
+ lab = new(ssaLabel)
+ s.labels[sym.Name] = lab
+ }
+ return lab
+}
+
+func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) }
+func (s *state) Log() bool { return s.config.Log() }
+func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(s.peekLine(), msg, args...) }
+func (s *state) Unimplementedf(msg string, args ...interface{}) {
+ s.config.Unimplementedf(s.peekLine(), msg, args...)
+}
+func (s *state) Warnl(line int, msg string, args ...interface{}) { s.config.Warnl(line, msg, args...) }
+func (s *state) Debug_checknil() bool { return s.config.Debug_checknil() }
+
+var (
+ // dummy node for the memory variable
+ memVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "mem"}}
+
+ // dummy nodes for temporary variables
+ ptrVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "ptr"}}
+ capVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "cap"}}
+ typVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "typ"}}
+ idataVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "idata"}}
+ okVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "ok"}}
+)
+
+// startBlock sets the current block we're generating code in to b.
+func (s *state) startBlock(b *ssa.Block) {
+ if s.curBlock != nil {
+ s.Fatalf("starting block %v when block %v has not ended", b, s.curBlock)
+ }
+ s.curBlock = b
+ s.vars = map[*Node]*ssa.Value{}
+}
+
+// endBlock marks the end of generating code for the current block.
+// Returns the (former) current block. Returns nil if there is no current
+// block, i.e. if no code flows to the current execution point.
+func (s *state) endBlock() *ssa.Block {
+ b := s.curBlock
+ if b == nil {
+ return nil
+ }
+ for len(s.defvars) <= int(b.ID) {
+ s.defvars = append(s.defvars, nil)
+ }
+ s.defvars[b.ID] = s.vars
+ s.curBlock = nil
+ s.vars = nil
+ b.Line = s.peekLine()
+ return b
+}
+
+// pushLine pushes a line number on the line number stack.
+func (s *state) pushLine(line int32) {
+ s.line = append(s.line, line)
+}
+
+// popLine pops the top of the line number stack.
+func (s *state) popLine() {
+ s.line = s.line[:len(s.line)-1]
+}
+
+// peekLine peek the top of the line number stack.
+func (s *state) peekLine() int32 {
+ return s.line[len(s.line)-1]
+}
+
+func (s *state) Error(msg string, args ...interface{}) {
+ yyerrorl(int(s.peekLine()), msg, args...)
+}
+
+// newValue0 adds a new value with no arguments to the current block.
+func (s *state) newValue0(op ssa.Op, t ssa.Type) *ssa.Value {
+ return s.curBlock.NewValue0(s.peekLine(), op, t)
+}
+
+// newValue0A adds a new value with no arguments and an aux value to the current block.
+func (s *state) newValue0A(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value {
+ return s.curBlock.NewValue0A(s.peekLine(), op, t, aux)
+}
+
+// newValue0I adds a new value with no arguments and an auxint value to the current block.
+func (s *state) newValue0I(op ssa.Op, t ssa.Type, auxint int64) *ssa.Value {
+ return s.curBlock.NewValue0I(s.peekLine(), op, t, auxint)
+}
+
+// newValue1 adds a new value with one argument to the current block.
+func (s *state) newValue1(op ssa.Op, t ssa.Type, arg *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue1(s.peekLine(), op, t, arg)
+}
+
+// newValue1A adds a new value with one argument and an aux value to the current block.
+func (s *state) newValue1A(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue1A(s.peekLine(), op, t, aux, arg)
+}
+
+// newValue1I adds a new value with one argument and an auxint value to the current block.
+func (s *state) newValue1I(op ssa.Op, t ssa.Type, aux int64, arg *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue1I(s.peekLine(), op, t, aux, arg)
+}
+
+// newValue2 adds a new value with two arguments to the current block.
+func (s *state) newValue2(op ssa.Op, t ssa.Type, arg0, arg1 *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue2(s.peekLine(), op, t, arg0, arg1)
+}
+
+// newValue2I adds a new value with two arguments and an auxint value to the current block.
+func (s *state) newValue2I(op ssa.Op, t ssa.Type, aux int64, arg0, arg1 *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue2I(s.peekLine(), op, t, aux, arg0, arg1)
+}
+
+// newValue3 adds a new value with three arguments to the current block.
+func (s *state) newValue3(op ssa.Op, t ssa.Type, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue3(s.peekLine(), op, t, arg0, arg1, arg2)
+}
+
+// newValue3I adds a new value with three arguments and an auxint value to the current block.
+func (s *state) newValue3I(op ssa.Op, t ssa.Type, aux int64, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue3I(s.peekLine(), op, t, aux, arg0, arg1, arg2)
+}
+
+// entryNewValue0 adds a new value with no arguments to the entry block.
+func (s *state) entryNewValue0(op ssa.Op, t ssa.Type) *ssa.Value {
+ return s.f.Entry.NewValue0(s.peekLine(), op, t)
+}
+
+// entryNewValue0A adds a new value with no arguments and an aux value to the entry block.
+func (s *state) entryNewValue0A(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value {
+ return s.f.Entry.NewValue0A(s.peekLine(), op, t, aux)
+}
+
+// entryNewValue0I adds a new value with no arguments and an auxint value to the entry block.
+func (s *state) entryNewValue0I(op ssa.Op, t ssa.Type, auxint int64) *ssa.Value {
+ return s.f.Entry.NewValue0I(s.peekLine(), op, t, auxint)
+}
+
+// entryNewValue1 adds a new value with one argument to the entry block.
+func (s *state) entryNewValue1(op ssa.Op, t ssa.Type, arg *ssa.Value) *ssa.Value {
+ return s.f.Entry.NewValue1(s.peekLine(), op, t, arg)
+}
+
+// entryNewValue1 adds a new value with one argument and an auxint value to the entry block.
+func (s *state) entryNewValue1I(op ssa.Op, t ssa.Type, auxint int64, arg *ssa.Value) *ssa.Value {
+ return s.f.Entry.NewValue1I(s.peekLine(), op, t, auxint, arg)
+}
+
+// entryNewValue1A adds a new value with one argument and an aux value to the entry block.
+func (s *state) entryNewValue1A(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+ return s.f.Entry.NewValue1A(s.peekLine(), op, t, aux, arg)
+}
+
+// entryNewValue2 adds a new value with two arguments to the entry block.
+func (s *state) entryNewValue2(op ssa.Op, t ssa.Type, arg0, arg1 *ssa.Value) *ssa.Value {
+ return s.f.Entry.NewValue2(s.peekLine(), op, t, arg0, arg1)
+}
+
+// const* routines add a new const value to the entry block.
+func (s *state) constBool(c bool) *ssa.Value {
+ return s.f.ConstBool(s.peekLine(), Types[TBOOL], c)
+}
+func (s *state) constInt8(t ssa.Type, c int8) *ssa.Value {
+ return s.f.ConstInt8(s.peekLine(), t, c)
+}
+func (s *state) constInt16(t ssa.Type, c int16) *ssa.Value {
+ return s.f.ConstInt16(s.peekLine(), t, c)
+}
+func (s *state) constInt32(t ssa.Type, c int32) *ssa.Value {
+ return s.f.ConstInt32(s.peekLine(), t, c)
+}
+func (s *state) constInt64(t ssa.Type, c int64) *ssa.Value {
+ return s.f.ConstInt64(s.peekLine(), t, c)
+}
+func (s *state) constFloat32(t ssa.Type, c float64) *ssa.Value {
+ return s.f.ConstFloat32(s.peekLine(), t, c)
+}
+func (s *state) constFloat64(t ssa.Type, c float64) *ssa.Value {
+ return s.f.ConstFloat64(s.peekLine(), t, c)
+}
+func (s *state) constInt(t ssa.Type, c int64) *ssa.Value {
+ if s.config.IntSize == 8 {
+ return s.constInt64(t, c)
+ }
+ if int64(int32(c)) != c {
+ s.Fatalf("integer constant too big %d", c)
+ }
+ return s.constInt32(t, int32(c))
+}
+
+func (s *state) stmts(a Nodes) {
+ for _, x := range a.Slice() {
+ s.stmt(x)
+ }
+}
+
+// ssaStmtList converts the statement n to SSA and adds it to s.
+func (s *state) stmtList(l *NodeList) {
+ for ; l != nil; l = l.Next {
+ s.stmt(l.N)
+ }
+}
+
+// ssaStmt converts the statement n to SSA and adds it to s.
+func (s *state) stmt(n *Node) {
+ s.pushLine(n.Lineno)
+ defer s.popLine()
+
+ // If s.curBlock is nil, then we're about to generate dead code.
+ // We can't just short-circuit here, though,
+ // because we check labels and gotos as part of SSA generation.
+ // Provide a block for the dead code so that we don't have
+ // to add special cases everywhere else.
+ if s.curBlock == nil {
+ dead := s.f.NewBlock(ssa.BlockPlain)
+ s.startBlock(dead)
+ }
+
+ s.stmtList(n.Ninit)
+ switch n.Op {
+
+ case OBLOCK:
+ s.stmtList(n.List)
+
+ // No-ops
+ case OEMPTY, ODCLCONST, ODCLTYPE, OFALL:
+
+ // Expression statements
+ case OCALLFUNC, OCALLMETH, OCALLINTER:
+ s.call(n, callNormal)
+ if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class == PFUNC &&
+ (compiling_runtime != 0 && n.Left.Sym.Name == "throw" ||
+ n.Left.Sym.Pkg == Runtimepkg && (n.Left.Sym.Name == "gopanic" || n.Left.Sym.Name == "selectgo" || n.Left.Sym.Name == "block")) {
+ m := s.mem()
+ b := s.endBlock()
+ b.Kind = ssa.BlockExit
+ b.Control = m
+ // TODO: never rewrite OPANIC to OCALLFUNC in the
+ // first place. Need to wait until all backends
+ // go through SSA.
+ }
+ case ODEFER:
+ s.call(n.Left, callDefer)
+ case OPROC:
+ s.call(n.Left, callGo)
+
+ case OAS2DOTTYPE:
+ res, resok := s.dottype(n.Rlist.N, true)
+ s.assign(n.List.N, res, needwritebarrier(n.List.N, n.Rlist.N), false, n.Lineno)
+ s.assign(n.List.Next.N, resok, false, false, n.Lineno)
+ return
+
+ case ODCL:
+ if n.Left.Class&PHEAP == 0 {
+ return
+ }
+ if compiling_runtime != 0 {
+ Fatalf("%v escapes to heap, not allowed in runtime.", n)
+ }
+
+ // TODO: the old pass hides the details of PHEAP
+ // variables behind ONAME nodes. Figure out if it's better
+ // to rewrite the tree and make the heapaddr construct explicit
+ // or to keep this detail hidden behind the scenes.
+ palloc := prealloc[n.Left]
+ if palloc == nil {
+ palloc = callnew(n.Left.Type)
+ prealloc[n.Left] = palloc
+ }
+ r := s.expr(palloc)
+ s.assign(n.Left.Name.Heapaddr, r, false, false, n.Lineno)
+
+ case OLABEL:
+ sym := n.Left.Sym
+
+ if isblanksym(sym) {
+ // Empty identifier is valid but useless.
+ // See issues 11589, 11593.
+ return
+ }
+
+ lab := s.label(sym)
+
+ // Associate label with its control flow node, if any
+ if ctl := n.Name.Defn; ctl != nil {
+ switch ctl.Op {
+ case OFOR, OSWITCH, OSELECT:
+ s.labeledNodes[ctl] = lab
+ }
+ }
+
+ if !lab.defined() {
+ lab.defNode = n
+ } else {
+ s.Error("label %v already defined at %v", sym, Ctxt.Line(int(lab.defNode.Lineno)))
+ lab.reported = true
+ }
+ // The label might already have a target block via a goto.
+ if lab.target == nil {
+ lab.target = s.f.NewBlock(ssa.BlockPlain)
+ }
+
+ // go to that label (we pretend "label:" is preceded by "goto label")
+ b := s.endBlock()
+ b.AddEdgeTo(lab.target)
+ s.startBlock(lab.target)
+
+ case OGOTO:
+ sym := n.Left.Sym
+
+ lab := s.label(sym)
+ if lab.target == nil {
+ lab.target = s.f.NewBlock(ssa.BlockPlain)
+ }
+ if !lab.used() {
+ lab.useNode = n
+ }
+
+ if lab.defined() {
+ s.checkgoto(n, lab.defNode)
+ } else {
+ s.fwdGotos = append(s.fwdGotos, n)
+ }
+
+ b := s.endBlock()
+ b.AddEdgeTo(lab.target)
+
+ case OAS, OASWB:
+ // Check whether we can generate static data rather than code.
+ // If so, ignore n and defer data generation until codegen.
+ // Failure to do this causes writes to readonly symbols.
+ if gen_as_init(n, true) {
+ var data []*Node
+ if s.f.StaticData != nil {
+ data = s.f.StaticData.([]*Node)
+ }
+ s.f.StaticData = append(data, n)
+ return
+ }
+
+ var t *Type
+ if n.Right != nil {
+ t = n.Right.Type
+ } else {
+ t = n.Left.Type
+ }
+
+ // Evaluate RHS.
+ rhs := n.Right
+ if rhs != nil && (rhs.Op == OSTRUCTLIT || rhs.Op == OARRAYLIT) {
+ // All literals with nonzero fields have already been
+ // rewritten during walk. Any that remain are just T{}
+ // or equivalents. Use the zero value.
+ if !iszero(rhs) {
+ Fatalf("literal with nonzero value in SSA: %v", rhs)
+ }
+ rhs = nil
+ }
+ var r *ssa.Value
+ needwb := n.Op == OASWB && rhs != nil
+ deref := !canSSAType(t)
+ if deref {
+ if rhs == nil {
+ r = nil // Signal assign to use OpZero.
+ } else {
+ r = s.addr(rhs, false)
+ }
+ } else {
+ if rhs == nil {
+ r = s.zeroVal(t)
+ } else {
+ r = s.expr(rhs)
+ }
+ }
+ if rhs != nil && rhs.Op == OAPPEND {
+ // Yuck! The frontend gets rid of the write barrier, but we need it!
+ // At least, we need it in the case where growslice is called.
+ // TODO: Do the write barrier on just the growslice branch.
+ // TODO: just add a ptr graying to the end of growslice?
+ // TODO: check whether we need to do this for ODOTTYPE and ORECV also.
+ // They get similar wb-removal treatment in walk.go:OAS.
+ needwb = true
+ }
+
+ s.assign(n.Left, r, needwb, deref, n.Lineno)
+
+ case OIF:
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+ var bElse *ssa.Block
+ if n.Rlist != nil {
+ bElse = s.f.NewBlock(ssa.BlockPlain)
+ s.condBranch(n.Left, bThen, bElse, n.Likely)
+ } else {
+ s.condBranch(n.Left, bThen, bEnd, n.Likely)
+ }
+
+ s.startBlock(bThen)
+ s.stmts(n.Nbody)
+ if b := s.endBlock(); b != nil {
+ b.AddEdgeTo(bEnd)
+ }
+
+ if n.Rlist != nil {
+ s.startBlock(bElse)
+ s.stmtList(n.Rlist)
+ if b := s.endBlock(); b != nil {
+ b.AddEdgeTo(bEnd)
+ }
+ }
+ s.startBlock(bEnd)
+
+ case ORETURN:
+ s.stmtList(n.List)
+ s.exit()
+ case ORETJMP:
+ s.stmtList(n.List)
+ b := s.exit()
+ b.Kind = ssa.BlockRetJmp // override BlockRet
+ b.Aux = n.Left.Sym
+
+ case OCONTINUE, OBREAK:
+ var op string
+ var to *ssa.Block
+ switch n.Op {
+ case OCONTINUE:
+ op = "continue"
+ to = s.continueTo
+ case OBREAK:
+ op = "break"
+ to = s.breakTo
+ }
+ if n.Left == nil {
+ // plain break/continue
+ if to == nil {
+ s.Error("%s is not in a loop", op)
+ return
+ }
+ // nothing to do; "to" is already the correct target
+ } else {
+ // labeled break/continue; look up the target
+ sym := n.Left.Sym
+ lab := s.label(sym)
+ if !lab.used() {
+ lab.useNode = n.Left
+ }
+ if !lab.defined() {
+ s.Error("%s label not defined: %v", op, sym)
+ lab.reported = true
+ return
+ }
+ switch n.Op {
+ case OCONTINUE:
+ to = lab.continueTarget
+ case OBREAK:
+ to = lab.breakTarget
+ }
+ if to == nil {
+ // Valid label but not usable with a break/continue here, e.g.:
+ // for {
+ // continue abc
+ // }
+ // abc:
+ // for {}
+ s.Error("invalid %s label %v", op, sym)
+ lab.reported = true
+ return
+ }
+ }
+
+ b := s.endBlock()
+ b.AddEdgeTo(to)
+
+ case OFOR:
+ // OFOR: for Ninit; Left; Right { Nbody }
+ bCond := s.f.NewBlock(ssa.BlockPlain)
+ bBody := s.f.NewBlock(ssa.BlockPlain)
+ bIncr := s.f.NewBlock(ssa.BlockPlain)
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ // first, jump to condition test
+ b := s.endBlock()
+ b.AddEdgeTo(bCond)
+
+ // generate code to test condition
+ s.startBlock(bCond)
+ if n.Left != nil {
+ s.condBranch(n.Left, bBody, bEnd, 1)
+ } else {
+ b := s.endBlock()
+ b.Kind = ssa.BlockPlain
+ b.AddEdgeTo(bBody)
+ }
+
+ // set up for continue/break in body
+ prevContinue := s.continueTo
+ prevBreak := s.breakTo
+ s.continueTo = bIncr
+ s.breakTo = bEnd
+ lab := s.labeledNodes[n]
+ if lab != nil {
+ // labeled for loop
+ lab.continueTarget = bIncr
+ lab.breakTarget = bEnd
+ }
+
+ // generate body
+ s.startBlock(bBody)
+ s.stmts(n.Nbody)
+
+ // tear down continue/break
+ s.continueTo = prevContinue
+ s.breakTo = prevBreak
+ if lab != nil {
+ lab.continueTarget = nil
+ lab.breakTarget = nil
+ }
+
+ // done with body, goto incr
+ if b := s.endBlock(); b != nil {
+ b.AddEdgeTo(bIncr)
+ }
+
+ // generate incr
+ s.startBlock(bIncr)
+ if n.Right != nil {
+ s.stmt(n.Right)
+ }
+ if b := s.endBlock(); b != nil {
+ b.AddEdgeTo(bCond)
+ }
+ s.startBlock(bEnd)
+
+ case OSWITCH, OSELECT:
+ // These have been mostly rewritten by the front end into their Nbody fields.
+ // Our main task is to correctly hook up any break statements.
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ prevBreak := s.breakTo
+ s.breakTo = bEnd
+ lab := s.labeledNodes[n]
+ if lab != nil {
+ // labeled
+ lab.breakTarget = bEnd
+ }
+
+ // generate body code
+ s.stmts(n.Nbody)
+
+ s.breakTo = prevBreak
+ if lab != nil {
+ lab.breakTarget = nil
+ }
+
+ // OSWITCH never falls through (s.curBlock == nil here).
+ // OSELECT does not fall through if we're calling selectgo.
+ // OSELECT does fall through if we're calling selectnb{send,recv}[2].
+ // In those latter cases, go to the code after the select.
+ if b := s.endBlock(); b != nil {
+ b.AddEdgeTo(bEnd)
+ }
+ s.startBlock(bEnd)
+
+ case OVARKILL:
+ // Insert a varkill op to record that a variable is no longer live.
+ // We only care about liveness info at call sites, so putting the
+ // varkill in the store chain is enough to keep it correctly ordered
+ // with respect to call ops.
+ if !s.canSSA(n.Left) {
+ s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem())
+ }
+
+ case OVARLIVE:
+ // Insert a varlive op to record that a variable is still live.
+ if !n.Left.Addrtaken {
+ s.Fatalf("VARLIVE variable %s must have Addrtaken set", n.Left)
+ }
+ s.vars[&memVar] = s.newValue1A(ssa.OpVarLive, ssa.TypeMem, n.Left, s.mem())
+
+ case OCHECKNIL:
+ p := s.expr(n.Left)
+ s.nilCheck(p)
+
+ default:
+ s.Unimplementedf("unhandled stmt %s", opnames[n.Op])
+ }
+}
+
+// exit processes any code that needs to be generated just before returning.
+// It returns a BlockRet block that ends the control flow. Its control value
+// will be set to the final memory state.
+func (s *state) exit() *ssa.Block {
+ // Run exit code. Typically, this code copies heap-allocated PPARAMOUT
+ // variables back to the stack.
+ s.stmts(s.exitCode)
+
+ // Store SSAable PPARAMOUT variables back to stack locations.
+ for _, n := range s.returns {
+ aux := &ssa.ArgSymbol{Typ: n.Type, Node: n}
+ addr := s.newValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp)
+ val := s.variable(n, n.Type)
+ s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, n, s.mem())
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, n.Type.Size(), addr, val, s.mem())
+ // TODO: if val is ever spilled, we'd like to use the
+ // PPARAMOUT slot for spilling it. That won't happen
+ // currently.
+ }
+
+ // Do actual return.
+ m := s.mem()
+ b := s.endBlock()
+ b.Kind = ssa.BlockRet
+ b.Control = m
+ return b
+}
+
+type opAndType struct {
+ op Op
+ etype EType
+}
+
+var opToSSA = map[opAndType]ssa.Op{
+ opAndType{OADD, TINT8}: ssa.OpAdd8,
+ opAndType{OADD, TUINT8}: ssa.OpAdd8,
+ opAndType{OADD, TINT16}: ssa.OpAdd16,
+ opAndType{OADD, TUINT16}: ssa.OpAdd16,
+ opAndType{OADD, TINT32}: ssa.OpAdd32,
+ opAndType{OADD, TUINT32}: ssa.OpAdd32,
+ opAndType{OADD, TPTR32}: ssa.OpAdd32,
+ opAndType{OADD, TINT64}: ssa.OpAdd64,
+ opAndType{OADD, TUINT64}: ssa.OpAdd64,
+ opAndType{OADD, TPTR64}: ssa.OpAdd64,
+ opAndType{OADD, TFLOAT32}: ssa.OpAdd32F,
+ opAndType{OADD, TFLOAT64}: ssa.OpAdd64F,
+
+ opAndType{OSUB, TINT8}: ssa.OpSub8,
+ opAndType{OSUB, TUINT8}: ssa.OpSub8,
+ opAndType{OSUB, TINT16}: ssa.OpSub16,
+ opAndType{OSUB, TUINT16}: ssa.OpSub16,
+ opAndType{OSUB, TINT32}: ssa.OpSub32,
+ opAndType{OSUB, TUINT32}: ssa.OpSub32,
+ opAndType{OSUB, TINT64}: ssa.OpSub64,
+ opAndType{OSUB, TUINT64}: ssa.OpSub64,
+ opAndType{OSUB, TFLOAT32}: ssa.OpSub32F,
+ opAndType{OSUB, TFLOAT64}: ssa.OpSub64F,
+
+ opAndType{ONOT, TBOOL}: ssa.OpNot,
+
+ opAndType{OMINUS, TINT8}: ssa.OpNeg8,
+ opAndType{OMINUS, TUINT8}: ssa.OpNeg8,
+ opAndType{OMINUS, TINT16}: ssa.OpNeg16,
+ opAndType{OMINUS, TUINT16}: ssa.OpNeg16,
+ opAndType{OMINUS, TINT32}: ssa.OpNeg32,
+ opAndType{OMINUS, TUINT32}: ssa.OpNeg32,
+ opAndType{OMINUS, TINT64}: ssa.OpNeg64,
+ opAndType{OMINUS, TUINT64}: ssa.OpNeg64,
+ opAndType{OMINUS, TFLOAT32}: ssa.OpNeg32F,
+ opAndType{OMINUS, TFLOAT64}: ssa.OpNeg64F,
+
+ opAndType{OCOM, TINT8}: ssa.OpCom8,
+ opAndType{OCOM, TUINT8}: ssa.OpCom8,
+ opAndType{OCOM, TINT16}: ssa.OpCom16,
+ opAndType{OCOM, TUINT16}: ssa.OpCom16,
+ opAndType{OCOM, TINT32}: ssa.OpCom32,
+ opAndType{OCOM, TUINT32}: ssa.OpCom32,
+ opAndType{OCOM, TINT64}: ssa.OpCom64,
+ opAndType{OCOM, TUINT64}: ssa.OpCom64,
+
+ opAndType{OIMAG, TCOMPLEX64}: ssa.OpComplexImag,
+ opAndType{OIMAG, TCOMPLEX128}: ssa.OpComplexImag,
+ opAndType{OREAL, TCOMPLEX64}: ssa.OpComplexReal,
+ opAndType{OREAL, TCOMPLEX128}: ssa.OpComplexReal,
+
+ opAndType{OMUL, TINT8}: ssa.OpMul8,
+ opAndType{OMUL, TUINT8}: ssa.OpMul8,
+ opAndType{OMUL, TINT16}: ssa.OpMul16,
+ opAndType{OMUL, TUINT16}: ssa.OpMul16,
+ opAndType{OMUL, TINT32}: ssa.OpMul32,
+ opAndType{OMUL, TUINT32}: ssa.OpMul32,
+ opAndType{OMUL, TINT64}: ssa.OpMul64,
+ opAndType{OMUL, TUINT64}: ssa.OpMul64,
+ opAndType{OMUL, TFLOAT32}: ssa.OpMul32F,
+ opAndType{OMUL, TFLOAT64}: ssa.OpMul64F,
+
+ opAndType{ODIV, TFLOAT32}: ssa.OpDiv32F,
+ opAndType{ODIV, TFLOAT64}: ssa.OpDiv64F,
+
+ opAndType{OHMUL, TINT8}: ssa.OpHmul8,
+ opAndType{OHMUL, TUINT8}: ssa.OpHmul8u,
+ opAndType{OHMUL, TINT16}: ssa.OpHmul16,
+ opAndType{OHMUL, TUINT16}: ssa.OpHmul16u,
+ opAndType{OHMUL, TINT32}: ssa.OpHmul32,
+ opAndType{OHMUL, TUINT32}: ssa.OpHmul32u,
+
+ opAndType{ODIV, TINT8}: ssa.OpDiv8,
+ opAndType{ODIV, TUINT8}: ssa.OpDiv8u,
+ opAndType{ODIV, TINT16}: ssa.OpDiv16,
+ opAndType{ODIV, TUINT16}: ssa.OpDiv16u,
+ opAndType{ODIV, TINT32}: ssa.OpDiv32,
+ opAndType{ODIV, TUINT32}: ssa.OpDiv32u,
+ opAndType{ODIV, TINT64}: ssa.OpDiv64,
+ opAndType{ODIV, TUINT64}: ssa.OpDiv64u,
+
+ opAndType{OMOD, TINT8}: ssa.OpMod8,
+ opAndType{OMOD, TUINT8}: ssa.OpMod8u,
+ opAndType{OMOD, TINT16}: ssa.OpMod16,
+ opAndType{OMOD, TUINT16}: ssa.OpMod16u,
+ opAndType{OMOD, TINT32}: ssa.OpMod32,
+ opAndType{OMOD, TUINT32}: ssa.OpMod32u,
+ opAndType{OMOD, TINT64}: ssa.OpMod64,
+ opAndType{OMOD, TUINT64}: ssa.OpMod64u,
+
+ opAndType{OAND, TINT8}: ssa.OpAnd8,
+ opAndType{OAND, TUINT8}: ssa.OpAnd8,
+ opAndType{OAND, TINT16}: ssa.OpAnd16,
+ opAndType{OAND, TUINT16}: ssa.OpAnd16,
+ opAndType{OAND, TINT32}: ssa.OpAnd32,
+ opAndType{OAND, TUINT32}: ssa.OpAnd32,
+ opAndType{OAND, TINT64}: ssa.OpAnd64,
+ opAndType{OAND, TUINT64}: ssa.OpAnd64,
+
+ opAndType{OOR, TINT8}: ssa.OpOr8,
+ opAndType{OOR, TUINT8}: ssa.OpOr8,
+ opAndType{OOR, TINT16}: ssa.OpOr16,
+ opAndType{OOR, TUINT16}: ssa.OpOr16,
+ opAndType{OOR, TINT32}: ssa.OpOr32,
+ opAndType{OOR, TUINT32}: ssa.OpOr32,
+ opAndType{OOR, TINT64}: ssa.OpOr64,
+ opAndType{OOR, TUINT64}: ssa.OpOr64,
+
+ opAndType{OXOR, TINT8}: ssa.OpXor8,
+ opAndType{OXOR, TUINT8}: ssa.OpXor8,
+ opAndType{OXOR, TINT16}: ssa.OpXor16,
+ opAndType{OXOR, TUINT16}: ssa.OpXor16,
+ opAndType{OXOR, TINT32}: ssa.OpXor32,
+ opAndType{OXOR, TUINT32}: ssa.OpXor32,
+ opAndType{OXOR, TINT64}: ssa.OpXor64,
+ opAndType{OXOR, TUINT64}: ssa.OpXor64,
+
+ opAndType{OEQ, TBOOL}: ssa.OpEq8,
+ opAndType{OEQ, TINT8}: ssa.OpEq8,
+ opAndType{OEQ, TUINT8}: ssa.OpEq8,
+ opAndType{OEQ, TINT16}: ssa.OpEq16,
+ opAndType{OEQ, TUINT16}: ssa.OpEq16,
+ opAndType{OEQ, TINT32}: ssa.OpEq32,
+ opAndType{OEQ, TUINT32}: ssa.OpEq32,
+ opAndType{OEQ, TINT64}: ssa.OpEq64,
+ opAndType{OEQ, TUINT64}: ssa.OpEq64,
+ opAndType{OEQ, TINTER}: ssa.OpEqInter,
+ opAndType{OEQ, TARRAY}: ssa.OpEqSlice,
+ opAndType{OEQ, TFUNC}: ssa.OpEqPtr,
+ opAndType{OEQ, TMAP}: ssa.OpEqPtr,
+ opAndType{OEQ, TCHAN}: ssa.OpEqPtr,
+ opAndType{OEQ, TPTR64}: ssa.OpEqPtr,
+ opAndType{OEQ, TUINTPTR}: ssa.OpEqPtr,
+ opAndType{OEQ, TUNSAFEPTR}: ssa.OpEqPtr,
+ opAndType{OEQ, TFLOAT64}: ssa.OpEq64F,
+ opAndType{OEQ, TFLOAT32}: ssa.OpEq32F,
+
+ opAndType{ONE, TBOOL}: ssa.OpNeq8,
+ opAndType{ONE, TINT8}: ssa.OpNeq8,
+ opAndType{ONE, TUINT8}: ssa.OpNeq8,
+ opAndType{ONE, TINT16}: ssa.OpNeq16,
+ opAndType{ONE, TUINT16}: ssa.OpNeq16,
+ opAndType{ONE, TINT32}: ssa.OpNeq32,
+ opAndType{ONE, TUINT32}: ssa.OpNeq32,
+ opAndType{ONE, TINT64}: ssa.OpNeq64,
+ opAndType{ONE, TUINT64}: ssa.OpNeq64,
+ opAndType{ONE, TINTER}: ssa.OpNeqInter,
+ opAndType{ONE, TARRAY}: ssa.OpNeqSlice,
+ opAndType{ONE, TFUNC}: ssa.OpNeqPtr,
+ opAndType{ONE, TMAP}: ssa.OpNeqPtr,
+ opAndType{ONE, TCHAN}: ssa.OpNeqPtr,
+ opAndType{ONE, TPTR64}: ssa.OpNeqPtr,
+ opAndType{ONE, TUINTPTR}: ssa.OpNeqPtr,
+ opAndType{ONE, TUNSAFEPTR}: ssa.OpNeqPtr,
+ opAndType{ONE, TFLOAT64}: ssa.OpNeq64F,
+ opAndType{ONE, TFLOAT32}: ssa.OpNeq32F,
+
+ opAndType{OLT, TINT8}: ssa.OpLess8,
+ opAndType{OLT, TUINT8}: ssa.OpLess8U,
+ opAndType{OLT, TINT16}: ssa.OpLess16,
+ opAndType{OLT, TUINT16}: ssa.OpLess16U,
+ opAndType{OLT, TINT32}: ssa.OpLess32,
+ opAndType{OLT, TUINT32}: ssa.OpLess32U,
+ opAndType{OLT, TINT64}: ssa.OpLess64,
+ opAndType{OLT, TUINT64}: ssa.OpLess64U,
+ opAndType{OLT, TFLOAT64}: ssa.OpLess64F,
+ opAndType{OLT, TFLOAT32}: ssa.OpLess32F,
+
+ opAndType{OGT, TINT8}: ssa.OpGreater8,
+ opAndType{OGT, TUINT8}: ssa.OpGreater8U,
+ opAndType{OGT, TINT16}: ssa.OpGreater16,
+ opAndType{OGT, TUINT16}: ssa.OpGreater16U,
+ opAndType{OGT, TINT32}: ssa.OpGreater32,
+ opAndType{OGT, TUINT32}: ssa.OpGreater32U,
+ opAndType{OGT, TINT64}: ssa.OpGreater64,
+ opAndType{OGT, TUINT64}: ssa.OpGreater64U,
+ opAndType{OGT, TFLOAT64}: ssa.OpGreater64F,
+ opAndType{OGT, TFLOAT32}: ssa.OpGreater32F,
+
+ opAndType{OLE, TINT8}: ssa.OpLeq8,
+ opAndType{OLE, TUINT8}: ssa.OpLeq8U,
+ opAndType{OLE, TINT16}: ssa.OpLeq16,
+ opAndType{OLE, TUINT16}: ssa.OpLeq16U,
+ opAndType{OLE, TINT32}: ssa.OpLeq32,
+ opAndType{OLE, TUINT32}: ssa.OpLeq32U,
+ opAndType{OLE, TINT64}: ssa.OpLeq64,
+ opAndType{OLE, TUINT64}: ssa.OpLeq64U,
+ opAndType{OLE, TFLOAT64}: ssa.OpLeq64F,
+ opAndType{OLE, TFLOAT32}: ssa.OpLeq32F,
+
+ opAndType{OGE, TINT8}: ssa.OpGeq8,
+ opAndType{OGE, TUINT8}: ssa.OpGeq8U,
+ opAndType{OGE, TINT16}: ssa.OpGeq16,
+ opAndType{OGE, TUINT16}: ssa.OpGeq16U,
+ opAndType{OGE, TINT32}: ssa.OpGeq32,
+ opAndType{OGE, TUINT32}: ssa.OpGeq32U,
+ opAndType{OGE, TINT64}: ssa.OpGeq64,
+ opAndType{OGE, TUINT64}: ssa.OpGeq64U,
+ opAndType{OGE, TFLOAT64}: ssa.OpGeq64F,
+ opAndType{OGE, TFLOAT32}: ssa.OpGeq32F,
+
+ opAndType{OLROT, TUINT8}: ssa.OpLrot8,
+ opAndType{OLROT, TUINT16}: ssa.OpLrot16,
+ opAndType{OLROT, TUINT32}: ssa.OpLrot32,
+ opAndType{OLROT, TUINT64}: ssa.OpLrot64,
+
+ opAndType{OSQRT, TFLOAT64}: ssa.OpSqrt,
+}
+
+func (s *state) concreteEtype(t *Type) EType {
+ e := t.Etype
+ switch e {
+ default:
+ return e
+ case TINT:
+ if s.config.IntSize == 8 {
+ return TINT64
+ }
+ return TINT32
+ case TUINT:
+ if s.config.IntSize == 8 {
+ return TUINT64
+ }
+ return TUINT32
+ case TUINTPTR:
+ if s.config.PtrSize == 8 {
+ return TUINT64
+ }
+ return TUINT32
+ }
+}
+
+func (s *state) ssaOp(op Op, t *Type) ssa.Op {
+ etype := s.concreteEtype(t)
+ x, ok := opToSSA[opAndType{op, etype}]
+ if !ok {
+ s.Unimplementedf("unhandled binary op %s %s", opnames[op], Econv(etype))
+ }
+ return x
+}
+
+func floatForComplex(t *Type) *Type {
+ if t.Size() == 8 {
+ return Types[TFLOAT32]
+ } else {
+ return Types[TFLOAT64]
+ }
+}
+
+type opAndTwoTypes struct {
+ op Op
+ etype1 EType
+ etype2 EType
+}
+
+type twoTypes struct {
+ etype1 EType
+ etype2 EType
+}
+
+type twoOpsAndType struct {
+ op1 ssa.Op
+ op2 ssa.Op
+ intermediateType EType
+}
+
+var fpConvOpToSSA = map[twoTypes]twoOpsAndType{
+
+ twoTypes{TINT8, TFLOAT32}: twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to32F, TINT32},
+ twoTypes{TINT16, TFLOAT32}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to32F, TINT32},
+ twoTypes{TINT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to32F, TINT32},
+ twoTypes{TINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to32F, TINT64},
+
+ twoTypes{TINT8, TFLOAT64}: twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to64F, TINT32},
+ twoTypes{TINT16, TFLOAT64}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to64F, TINT32},
+ twoTypes{TINT32, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to64F, TINT32},
+ twoTypes{TINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to64F, TINT64},
+
+ twoTypes{TFLOAT32, TINT8}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
+ twoTypes{TFLOAT32, TINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
+ twoTypes{TFLOAT32, TINT32}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpCopy, TINT32},
+ twoTypes{TFLOAT32, TINT64}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpCopy, TINT64},
+
+ twoTypes{TFLOAT64, TINT8}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
+ twoTypes{TFLOAT64, TINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
+ twoTypes{TFLOAT64, TINT32}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpCopy, TINT32},
+ twoTypes{TFLOAT64, TINT64}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpCopy, TINT64},
+ // unsigned
+ twoTypes{TUINT8, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to32F, TINT32},
+ twoTypes{TUINT16, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to32F, TINT32},
+ twoTypes{TUINT32, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to32F, TINT64}, // go wide to dodge unsigned
+ twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64}, // Cvt64Uto32F, branchy code expansion instead
+
+ twoTypes{TUINT8, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to64F, TINT32},
+ twoTypes{TUINT16, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to64F, TINT32},
+ twoTypes{TUINT32, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to64F, TINT64}, // go wide to dodge unsigned
+ twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64}, // Cvt64Uto64F, branchy code expansion instead
+
+ twoTypes{TFLOAT32, TUINT8}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
+ twoTypes{TFLOAT32, TUINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
+ twoTypes{TFLOAT32, TUINT32}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
+ twoTypes{TFLOAT32, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64}, // Cvt32Fto64U, branchy code expansion instead
+
+ twoTypes{TFLOAT64, TUINT8}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
+ twoTypes{TFLOAT64, TUINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
+ twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
+ twoTypes{TFLOAT64, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64}, // Cvt64Fto64U, branchy code expansion instead
+
+ // float
+ twoTypes{TFLOAT64, TFLOAT32}: twoOpsAndType{ssa.OpCvt64Fto32F, ssa.OpCopy, TFLOAT32},
+ twoTypes{TFLOAT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCopy, TFLOAT64},
+ twoTypes{TFLOAT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCopy, TFLOAT32},
+ twoTypes{TFLOAT32, TFLOAT64}: twoOpsAndType{ssa.OpCvt32Fto64F, ssa.OpCopy, TFLOAT64},
+}
+
+var shiftOpToSSA = map[opAndTwoTypes]ssa.Op{
+ opAndTwoTypes{OLSH, TINT8, TUINT8}: ssa.OpLsh8x8,
+ opAndTwoTypes{OLSH, TUINT8, TUINT8}: ssa.OpLsh8x8,
+ opAndTwoTypes{OLSH, TINT8, TUINT16}: ssa.OpLsh8x16,
+ opAndTwoTypes{OLSH, TUINT8, TUINT16}: ssa.OpLsh8x16,
+ opAndTwoTypes{OLSH, TINT8, TUINT32}: ssa.OpLsh8x32,
+ opAndTwoTypes{OLSH, TUINT8, TUINT32}: ssa.OpLsh8x32,
+ opAndTwoTypes{OLSH, TINT8, TUINT64}: ssa.OpLsh8x64,
+ opAndTwoTypes{OLSH, TUINT8, TUINT64}: ssa.OpLsh8x64,
+
+ opAndTwoTypes{OLSH, TINT16, TUINT8}: ssa.OpLsh16x8,
+ opAndTwoTypes{OLSH, TUINT16, TUINT8}: ssa.OpLsh16x8,
+ opAndTwoTypes{OLSH, TINT16, TUINT16}: ssa.OpLsh16x16,
+ opAndTwoTypes{OLSH, TUINT16, TUINT16}: ssa.OpLsh16x16,
+ opAndTwoTypes{OLSH, TINT16, TUINT32}: ssa.OpLsh16x32,
+ opAndTwoTypes{OLSH, TUINT16, TUINT32}: ssa.OpLsh16x32,
+ opAndTwoTypes{OLSH, TINT16, TUINT64}: ssa.OpLsh16x64,
+ opAndTwoTypes{OLSH, TUINT16, TUINT64}: ssa.OpLsh16x64,
+
+ opAndTwoTypes{OLSH, TINT32, TUINT8}: ssa.OpLsh32x8,
+ opAndTwoTypes{OLSH, TUINT32, TUINT8}: ssa.OpLsh32x8,
+ opAndTwoTypes{OLSH, TINT32, TUINT16}: ssa.OpLsh32x16,
+ opAndTwoTypes{OLSH, TUINT32, TUINT16}: ssa.OpLsh32x16,
+ opAndTwoTypes{OLSH, TINT32, TUINT32}: ssa.OpLsh32x32,
+ opAndTwoTypes{OLSH, TUINT32, TUINT32}: ssa.OpLsh32x32,
+ opAndTwoTypes{OLSH, TINT32, TUINT64}: ssa.OpLsh32x64,
+ opAndTwoTypes{OLSH, TUINT32, TUINT64}: ssa.OpLsh32x64,
+
+ opAndTwoTypes{OLSH, TINT64, TUINT8}: ssa.OpLsh64x8,
+ opAndTwoTypes{OLSH, TUINT64, TUINT8}: ssa.OpLsh64x8,
+ opAndTwoTypes{OLSH, TINT64, TUINT16}: ssa.OpLsh64x16,
+ opAndTwoTypes{OLSH, TUINT64, TUINT16}: ssa.OpLsh64x16,
+ opAndTwoTypes{OLSH, TINT64, TUINT32}: ssa.OpLsh64x32,
+ opAndTwoTypes{OLSH, TUINT64, TUINT32}: ssa.OpLsh64x32,
+ opAndTwoTypes{OLSH, TINT64, TUINT64}: ssa.OpLsh64x64,
+ opAndTwoTypes{OLSH, TUINT64, TUINT64}: ssa.OpLsh64x64,
+
+ opAndTwoTypes{ORSH, TINT8, TUINT8}: ssa.OpRsh8x8,
+ opAndTwoTypes{ORSH, TUINT8, TUINT8}: ssa.OpRsh8Ux8,
+ opAndTwoTypes{ORSH, TINT8, TUINT16}: ssa.OpRsh8x16,
+ opAndTwoTypes{ORSH, TUINT8, TUINT16}: ssa.OpRsh8Ux16,
+ opAndTwoTypes{ORSH, TINT8, TUINT32}: ssa.OpRsh8x32,
+ opAndTwoTypes{ORSH, TUINT8, TUINT32}: ssa.OpRsh8Ux32,
+ opAndTwoTypes{ORSH, TINT8, TUINT64}: ssa.OpRsh8x64,
+ opAndTwoTypes{ORSH, TUINT8, TUINT64}: ssa.OpRsh8Ux64,
+
+ opAndTwoTypes{ORSH, TINT16, TUINT8}: ssa.OpRsh16x8,
+ opAndTwoTypes{ORSH, TUINT16, TUINT8}: ssa.OpRsh16Ux8,
+ opAndTwoTypes{ORSH, TINT16, TUINT16}: ssa.OpRsh16x16,
+ opAndTwoTypes{ORSH, TUINT16, TUINT16}: ssa.OpRsh16Ux16,
+ opAndTwoTypes{ORSH, TINT16, TUINT32}: ssa.OpRsh16x32,
+ opAndTwoTypes{ORSH, TUINT16, TUINT32}: ssa.OpRsh16Ux32,
+ opAndTwoTypes{ORSH, TINT16, TUINT64}: ssa.OpRsh16x64,
+ opAndTwoTypes{ORSH, TUINT16, TUINT64}: ssa.OpRsh16Ux64,
+
+ opAndTwoTypes{ORSH, TINT32, TUINT8}: ssa.OpRsh32x8,
+ opAndTwoTypes{ORSH, TUINT32, TUINT8}: ssa.OpRsh32Ux8,
+ opAndTwoTypes{ORSH, TINT32, TUINT16}: ssa.OpRsh32x16,
+ opAndTwoTypes{ORSH, TUINT32, TUINT16}: ssa.OpRsh32Ux16,
+ opAndTwoTypes{ORSH, TINT32, TUINT32}: ssa.OpRsh32x32,
+ opAndTwoTypes{ORSH, TUINT32, TUINT32}: ssa.OpRsh32Ux32,
+ opAndTwoTypes{ORSH, TINT32, TUINT64}: ssa.OpRsh32x64,
+ opAndTwoTypes{ORSH, TUINT32, TUINT64}: ssa.OpRsh32Ux64,
+
+ opAndTwoTypes{ORSH, TINT64, TUINT8}: ssa.OpRsh64x8,
+ opAndTwoTypes{ORSH, TUINT64, TUINT8}: ssa.OpRsh64Ux8,
+ opAndTwoTypes{ORSH, TINT64, TUINT16}: ssa.OpRsh64x16,
+ opAndTwoTypes{ORSH, TUINT64, TUINT16}: ssa.OpRsh64Ux16,
+ opAndTwoTypes{ORSH, TINT64, TUINT32}: ssa.OpRsh64x32,
+ opAndTwoTypes{ORSH, TUINT64, TUINT32}: ssa.OpRsh64Ux32,
+ opAndTwoTypes{ORSH, TINT64, TUINT64}: ssa.OpRsh64x64,
+ opAndTwoTypes{ORSH, TUINT64, TUINT64}: ssa.OpRsh64Ux64,
+}
+
+func (s *state) ssaShiftOp(op Op, t *Type, u *Type) ssa.Op {
+ etype1 := s.concreteEtype(t)
+ etype2 := s.concreteEtype(u)
+ x, ok := shiftOpToSSA[opAndTwoTypes{op, etype1, etype2}]
+ if !ok {
+ s.Unimplementedf("unhandled shift op %s etype=%s/%s", opnames[op], Econv(etype1), Econv(etype2))
+ }
+ return x
+}
+
+func (s *state) ssaRotateOp(op Op, t *Type) ssa.Op {
+ etype1 := s.concreteEtype(t)
+ x, ok := opToSSA[opAndType{op, etype1}]
+ if !ok {
+ s.Unimplementedf("unhandled rotate op %s etype=%s", opnames[op], Econv(etype1))
+ }
+ return x
+}
+
+// expr converts the expression n to ssa, adds it to s and returns the ssa result.
+func (s *state) expr(n *Node) *ssa.Value {
+ s.pushLine(n.Lineno)
+ defer s.popLine()
+
+ s.stmtList(n.Ninit)
+ switch n.Op {
+ case OCFUNC:
+ aux := s.lookupSymbol(n, &ssa.ExternSymbol{n.Type, n.Left.Sym})
+ return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb)
+ case OPARAM:
+ addr := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Left.Type, addr, s.mem())
+ case ONAME:
+ if n.Class == PFUNC {
+ // "value" of a function is the address of the function's closure
+ sym := funcsym(n.Sym)
+ aux := &ssa.ExternSymbol{n.Type, sym}
+ return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb)
+ }
+ if s.canSSA(n) {
+ return s.variable(n, n.Type)
+ }
+ addr := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem())
+ case OCLOSUREVAR:
+ addr := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem())
+ case OLITERAL:
+ switch n.Val().Ctype() {
+ case CTINT:
+ i := Mpgetfix(n.Val().U.(*Mpint))
+ switch n.Type.Size() {
+ case 1:
+ return s.constInt8(n.Type, int8(i))
+ case 2:
+ return s.constInt16(n.Type, int16(i))
+ case 4:
+ return s.constInt32(n.Type, int32(i))
+ case 8:
+ return s.constInt64(n.Type, i)
+ default:
+ s.Fatalf("bad integer size %d", n.Type.Size())
+ return nil
+ }
+ case CTSTR:
+ return s.entryNewValue0A(ssa.OpConstString, n.Type, n.Val().U)
+ case CTBOOL:
+ v := s.constBool(n.Val().U.(bool))
+ // For some reason the frontend gets the line numbers of
+ // CTBOOL literals totally wrong. Fix it here by grabbing
+ // the line number of the enclosing AST node.
+ if len(s.line) >= 2 {
+ v.Line = s.line[len(s.line)-2]
+ }
+ return v
+ case CTNIL:
+ t := n.Type
+ switch {
+ case t.IsSlice():
+ return s.entryNewValue0(ssa.OpConstSlice, t)
+ case t.IsInterface():
+ return s.entryNewValue0(ssa.OpConstInterface, t)
+ default:
+ return s.entryNewValue0(ssa.OpConstNil, t)
+ }
+ case CTFLT:
+ f := n.Val().U.(*Mpflt)
+ switch n.Type.Size() {
+ case 4:
+ return s.constFloat32(n.Type, mpgetflt32(f))
+ case 8:
+ return s.constFloat64(n.Type, mpgetflt(f))
+ default:
+ s.Fatalf("bad float size %d", n.Type.Size())
+ return nil
+ }
+ case CTCPLX:
+ c := n.Val().U.(*Mpcplx)
+ r := &c.Real
+ i := &c.Imag
+ switch n.Type.Size() {
+ case 8:
+ {
+ pt := Types[TFLOAT32]
+ return s.newValue2(ssa.OpComplexMake, n.Type,
+ s.constFloat32(pt, mpgetflt32(r)),
+ s.constFloat32(pt, mpgetflt32(i)))
+ }
+ case 16:
+ {
+ pt := Types[TFLOAT64]
+ return s.newValue2(ssa.OpComplexMake, n.Type,
+ s.constFloat64(pt, mpgetflt(r)),
+ s.constFloat64(pt, mpgetflt(i)))
+ }
+ default:
+ s.Fatalf("bad float size %d", n.Type.Size())
+ return nil
+ }
+
+ default:
+ s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype())
+ return nil
+ }
+ case OCONVNOP:
+ to := n.Type
+ from := n.Left.Type
+
+ // Assume everything will work out, so set up our return value.
+ // Anything interesting that happens from here is a fatal.
+ x := s.expr(n.Left)
+
+ // Special case for not confusing GC and liveness.
+ // We don't want pointers accidentally classified
+ // as not-pointers or vice-versa because of copy
+ // elision.
+ if to.IsPtr() != from.IsPtr() {
+ return s.newValue2(ssa.OpConvert, to, x, s.mem())
+ }
+
+ v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type
+
+ // CONVNOP closure
+ if to.Etype == TFUNC && from.IsPtr() {
+ return v
+ }
+
+ // named <--> unnamed type or typed <--> untyped const
+ if from.Etype == to.Etype {
+ return v
+ }
+
+ // unsafe.Pointer <--> *T
+ if to.Etype == TUNSAFEPTR && from.IsPtr() || from.Etype == TUNSAFEPTR && to.IsPtr() {
+ return v
+ }
+
+ dowidth(from)
+ dowidth(to)
+ if from.Width != to.Width {
+ s.Fatalf("CONVNOP width mismatch %v (%d) -> %v (%d)\n", from, from.Width, to, to.Width)
+ return nil
+ }
+ if etypesign(from.Etype) != etypesign(to.Etype) {
+ s.Fatalf("CONVNOP sign mismatch %v (%s) -> %v (%s)\n", from, Econv(from.Etype), to, Econv(to.Etype))
+ return nil
+ }
+
+ if flag_race != 0 {
+ // These appear to be fine, but they fail the
+ // integer constraint below, so okay them here.
+ // Sample non-integer conversion: map[string]string -> *uint8
+ return v
+ }
+
+ if etypesign(from.Etype) == 0 {
+ s.Fatalf("CONVNOP unrecognized non-integer %v -> %v\n", from, to)
+ return nil
+ }
+
+ // integer, same width, same sign
+ return v
+
+ case OCONV:
+ x := s.expr(n.Left)
+ ft := n.Left.Type // from type
+ tt := n.Type // to type
+ if ft.IsInteger() && tt.IsInteger() {
+ var op ssa.Op
+ if tt.Size() == ft.Size() {
+ op = ssa.OpCopy
+ } else if tt.Size() < ft.Size() {
+ // truncation
+ switch 10*ft.Size() + tt.Size() {
+ case 21:
+ op = ssa.OpTrunc16to8
+ case 41:
+ op = ssa.OpTrunc32to8
+ case 42:
+ op = ssa.OpTrunc32to16
+ case 81:
+ op = ssa.OpTrunc64to8
+ case 82:
+ op = ssa.OpTrunc64to16
+ case 84:
+ op = ssa.OpTrunc64to32
+ default:
+ s.Fatalf("weird integer truncation %s -> %s", ft, tt)
+ }
+ } else if ft.IsSigned() {
+ // sign extension
+ switch 10*ft.Size() + tt.Size() {
+ case 12:
+ op = ssa.OpSignExt8to16
+ case 14:
+ op = ssa.OpSignExt8to32
+ case 18:
+ op = ssa.OpSignExt8to64
+ case 24:
+ op = ssa.OpSignExt16to32
+ case 28:
+ op = ssa.OpSignExt16to64
+ case 48:
+ op = ssa.OpSignExt32to64
+ default:
+ s.Fatalf("bad integer sign extension %s -> %s", ft, tt)
+ }
+ } else {
+ // zero extension
+ switch 10*ft.Size() + tt.Size() {
+ case 12:
+ op = ssa.OpZeroExt8to16
+ case 14:
+ op = ssa.OpZeroExt8to32
+ case 18:
+ op = ssa.OpZeroExt8to64
+ case 24:
+ op = ssa.OpZeroExt16to32
+ case 28:
+ op = ssa.OpZeroExt16to64
+ case 48:
+ op = ssa.OpZeroExt32to64
+ default:
+ s.Fatalf("weird integer sign extension %s -> %s", ft, tt)
+ }
+ }
+ return s.newValue1(op, n.Type, x)
+ }
+
+ if ft.IsFloat() || tt.IsFloat() {
+ conv, ok := fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]
+ if !ok {
+ s.Fatalf("weird float conversion %s -> %s", ft, tt)
+ }
+ op1, op2, it := conv.op1, conv.op2, conv.intermediateType
+
+ if op1 != ssa.OpInvalid && op2 != ssa.OpInvalid {
+ // normal case, not tripping over unsigned 64
+ if op1 == ssa.OpCopy {
+ if op2 == ssa.OpCopy {
+ return x
+ }
+ return s.newValue1(op2, n.Type, x)
+ }
+ if op2 == ssa.OpCopy {
+ return s.newValue1(op1, n.Type, x)
+ }
+ return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x))
+ }
+ // Tricky 64-bit unsigned cases.
+ if ft.IsInteger() {
+ // therefore tt is float32 or float64, and ft is also unsigned
+ if tt.Size() == 4 {
+ return s.uint64Tofloat32(n, x, ft, tt)
+ }
+ if tt.Size() == 8 {
+ return s.uint64Tofloat64(n, x, ft, tt)
+ }
+ s.Fatalf("weird unsigned integer to float conversion %s -> %s", ft, tt)
+ }
+ // therefore ft is float32 or float64, and tt is unsigned integer
+ if ft.Size() == 4 {
+ return s.float32ToUint64(n, x, ft, tt)
+ }
+ if ft.Size() == 8 {
+ return s.float64ToUint64(n, x, ft, tt)
+ }
+ s.Fatalf("weird float to unsigned integer conversion %s -> %s", ft, tt)
+ return nil
+ }
+
+ if ft.IsComplex() && tt.IsComplex() {
+ var op ssa.Op
+ if ft.Size() == tt.Size() {
+ op = ssa.OpCopy
+ } else if ft.Size() == 8 && tt.Size() == 16 {
+ op = ssa.OpCvt32Fto64F
+ } else if ft.Size() == 16 && tt.Size() == 8 {
+ op = ssa.OpCvt64Fto32F
+ } else {
+ s.Fatalf("weird complex conversion %s -> %s", ft, tt)
+ }
+ ftp := floatForComplex(ft)
+ ttp := floatForComplex(tt)
+ return s.newValue2(ssa.OpComplexMake, tt,
+ s.newValue1(op, ttp, s.newValue1(ssa.OpComplexReal, ftp, x)),
+ s.newValue1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
+ }
+
+ s.Unimplementedf("unhandled OCONV %s -> %s", Econv(n.Left.Type.Etype), Econv(n.Type.Etype))
+ return nil
+
+ case ODOTTYPE:
+ res, _ := s.dottype(n, false)
+ return res
+
+ // binary ops
+ case OLT, OEQ, ONE, OLE, OGE, OGT:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ if n.Left.Type.IsComplex() {
+ pt := floatForComplex(n.Left.Type)
+ op := s.ssaOp(OEQ, pt)
+ r := s.newValue2(op, Types[TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
+ i := s.newValue2(op, Types[TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
+ c := s.newValue2(ssa.OpAnd8, Types[TBOOL], r, i)
+ switch n.Op {
+ case OEQ:
+ return c
+ case ONE:
+ return s.newValue1(ssa.OpNot, Types[TBOOL], c)
+ default:
+ s.Fatalf("ordered complex compare %s", opnames[n.Op])
+ }
+ }
+ return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b)
+ case OMUL:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ if n.Type.IsComplex() {
+ mulop := ssa.OpMul64F
+ addop := ssa.OpAdd64F
+ subop := ssa.OpSub64F
+ pt := floatForComplex(n.Type) // Could be Float32 or Float64
+ wt := Types[TFLOAT64] // Compute in Float64 to minimize cancellation error
+
+ areal := s.newValue1(ssa.OpComplexReal, pt, a)
+ breal := s.newValue1(ssa.OpComplexReal, pt, b)
+ aimag := s.newValue1(ssa.OpComplexImag, pt, a)
+ bimag := s.newValue1(ssa.OpComplexImag, pt, b)
+
+ if pt != wt { // Widen for calculation
+ areal = s.newValue1(ssa.OpCvt32Fto64F, wt, areal)
+ breal = s.newValue1(ssa.OpCvt32Fto64F, wt, breal)
+ aimag = s.newValue1(ssa.OpCvt32Fto64F, wt, aimag)
+ bimag = s.newValue1(ssa.OpCvt32Fto64F, wt, bimag)
+ }
+
+ xreal := s.newValue2(subop, wt, s.newValue2(mulop, wt, areal, breal), s.newValue2(mulop, wt, aimag, bimag))
+ ximag := s.newValue2(addop, wt, s.newValue2(mulop, wt, areal, bimag), s.newValue2(mulop, wt, aimag, breal))
+
+ if pt != wt { // Narrow to store back
+ xreal = s.newValue1(ssa.OpCvt64Fto32F, pt, xreal)
+ ximag = s.newValue1(ssa.OpCvt64Fto32F, pt, ximag)
+ }
+
+ return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+ }
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+
+ case ODIV:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ if n.Type.IsComplex() {
+ // TODO this is not executed because the front-end substitutes a runtime call.
+ // That probably ought to change; with modest optimization the widen/narrow
+ // conversions could all be elided in larger expression trees.
+ mulop := ssa.OpMul64F
+ addop := ssa.OpAdd64F
+ subop := ssa.OpSub64F
+ divop := ssa.OpDiv64F
+ pt := floatForComplex(n.Type) // Could be Float32 or Float64
+ wt := Types[TFLOAT64] // Compute in Float64 to minimize cancellation error
+
+ areal := s.newValue1(ssa.OpComplexReal, pt, a)
+ breal := s.newValue1(ssa.OpComplexReal, pt, b)
+ aimag := s.newValue1(ssa.OpComplexImag, pt, a)
+ bimag := s.newValue1(ssa.OpComplexImag, pt, b)
+
+ if pt != wt { // Widen for calculation
+ areal = s.newValue1(ssa.OpCvt32Fto64F, wt, areal)
+ breal = s.newValue1(ssa.OpCvt32Fto64F, wt, breal)
+ aimag = s.newValue1(ssa.OpCvt32Fto64F, wt, aimag)
+ bimag = s.newValue1(ssa.OpCvt32Fto64F, wt, bimag)
+ }
+
+ denom := s.newValue2(addop, wt, s.newValue2(mulop, wt, breal, breal), s.newValue2(mulop, wt, bimag, bimag))
+ xreal := s.newValue2(addop, wt, s.newValue2(mulop, wt, areal, breal), s.newValue2(mulop, wt, aimag, bimag))
+ ximag := s.newValue2(subop, wt, s.newValue2(mulop, wt, aimag, breal), s.newValue2(mulop, wt, areal, bimag))
+
+ // TODO not sure if this is best done in wide precision or narrow
+ // Double-rounding might be an issue.
+ // Note that the pre-SSA implementation does the entire calculation
+ // in wide format, so wide is compatible.
+ xreal = s.newValue2(divop, wt, xreal, denom)
+ ximag = s.newValue2(divop, wt, ximag, denom)
+
+ if pt != wt { // Narrow to store back
+ xreal = s.newValue1(ssa.OpCvt64Fto32F, pt, xreal)
+ ximag = s.newValue1(ssa.OpCvt64Fto32F, pt, ximag)
+ }
+ return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+ }
+ if n.Type.IsFloat() {
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+ } else {
+ // do a size-appropriate check for zero
+ cmp := s.newValue2(s.ssaOp(ONE, n.Type), Types[TBOOL], b, s.zeroVal(n.Type))
+ s.check(cmp, panicdivide)
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+ }
+ case OMOD:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ // do a size-appropriate check for zero
+ cmp := s.newValue2(s.ssaOp(ONE, n.Type), Types[TBOOL], b, s.zeroVal(n.Type))
+ s.check(cmp, panicdivide)
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+ case OADD, OSUB:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ if n.Type.IsComplex() {
+ pt := floatForComplex(n.Type)
+ op := s.ssaOp(n.Op, pt)
+ return s.newValue2(ssa.OpComplexMake, n.Type,
+ s.newValue2(op, pt, s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b)),
+ s.newValue2(op, pt, s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b)))
+ }
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+ case OAND, OOR, OHMUL, OXOR:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+ case OLSH, ORSH:
+ a := s.expr(n.Left)
+ b := s.expr(n.Right)
+ return s.newValue2(s.ssaShiftOp(n.Op, n.Type, n.Right.Type), a.Type, a, b)
+ case OLROT:
+ a := s.expr(n.Left)
+ i := n.Right.Int()
+ if i <= 0 || i >= n.Type.Size()*8 {
+ s.Fatalf("Wrong rotate distance for LROT, expected 1 through %d, saw %d", n.Type.Size()*8-1, i)
+ }
+ return s.newValue1I(s.ssaRotateOp(n.Op, n.Type), a.Type, i, a)
+ case OANDAND, OOROR:
+ // To implement OANDAND (and OOROR), we introduce a
+ // new temporary variable to hold the result. The
+ // variable is associated with the OANDAND node in the
+ // s.vars table (normally variables are only
+ // associated with ONAME nodes). We convert
+ // A && B
+ // to
+ // var = A
+ // if var {
+ // var = B
+ // }
+ // Using var in the subsequent block introduces the
+ // necessary phi variable.
+ el := s.expr(n.Left)
+ s.vars[n] = el
+
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = el
+ // In theory, we should set b.Likely here based on context.
+ // However, gc only gives us likeliness hints
+ // in a single place, for plain OIF statements,
+ // and passing around context is finnicky, so don't bother for now.
+
+ bRight := s.f.NewBlock(ssa.BlockPlain)
+ bResult := s.f.NewBlock(ssa.BlockPlain)
+ if n.Op == OANDAND {
+ b.AddEdgeTo(bRight)
+ b.AddEdgeTo(bResult)
+ } else if n.Op == OOROR {
+ b.AddEdgeTo(bResult)
+ b.AddEdgeTo(bRight)
+ }
+
+ s.startBlock(bRight)
+ er := s.expr(n.Right)
+ s.vars[n] = er
+
+ b = s.endBlock()
+ b.AddEdgeTo(bResult)
+
+ s.startBlock(bResult)
+ return s.variable(n, Types[TBOOL])
+ case OCOMPLEX:
+ r := s.expr(n.Left)
+ i := s.expr(n.Right)
+ return s.newValue2(ssa.OpComplexMake, n.Type, r, i)
+
+ // unary ops
+ case OMINUS:
+ a := s.expr(n.Left)
+ if n.Type.IsComplex() {
+ tp := floatForComplex(n.Type)
+ negop := s.ssaOp(n.Op, tp)
+ return s.newValue2(ssa.OpComplexMake, n.Type,
+ s.newValue1(negop, tp, s.newValue1(ssa.OpComplexReal, tp, a)),
+ s.newValue1(negop, tp, s.newValue1(ssa.OpComplexImag, tp, a)))
+ }
+ return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
+ case ONOT, OCOM, OSQRT:
+ a := s.expr(n.Left)
+ return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
+ case OIMAG, OREAL:
+ a := s.expr(n.Left)
+ return s.newValue1(s.ssaOp(n.Op, n.Left.Type), n.Type, a)
+ case OPLUS:
+ return s.expr(n.Left)
+
+ case OADDR:
+ return s.addr(n.Left, n.Bounded)
+
+ case OINDREG:
+ if int(n.Reg) != Thearch.REGSP {
+ s.Unimplementedf("OINDREG of non-SP register %s in expr: %v", obj.Rconv(int(n.Reg)), n)
+ return nil
+ }
+ addr := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp)
+ return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem())
+
+ case OIND:
+ p := s.expr(n.Left)
+ s.nilCheck(p)
+ return s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
+
+ case ODOT:
+ t := n.Left.Type
+ if canSSAType(t) {
+ v := s.expr(n.Left)
+ return s.newValue1I(ssa.OpStructSelect, n.Type, fieldIdx(n), v)
+ }
+ p := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
+
+ case ODOTPTR:
+ p := s.expr(n.Left)
+ s.nilCheck(p)
+ p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(Types[TINT], n.Xoffset))
+ return s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
+
+ case OINDEX:
+ switch {
+ case n.Left.Type.IsString():
+ a := s.expr(n.Left)
+ i := s.expr(n.Right)
+ i = s.extendIndex(i)
+ if !n.Bounded {
+ len := s.newValue1(ssa.OpStringLen, Types[TINT], a)
+ s.boundsCheck(i, len)
+ }
+ ptrtyp := Ptrto(Types[TUINT8])
+ ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
+ ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
+ return s.newValue2(ssa.OpLoad, Types[TUINT8], ptr, s.mem())
+ case n.Left.Type.IsSlice():
+ p := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem())
+ case n.Left.Type.IsArray():
+ // TODO: fix when we can SSA arrays of length 1.
+ p := s.addr(n, false)
+ return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem())
+ default:
+ s.Fatalf("bad type for index %v", n.Left.Type)
+ return nil
+ }
+
+ case OLEN, OCAP:
+ switch {
+ case n.Left.Type.IsSlice():
+ op := ssa.OpSliceLen
+ if n.Op == OCAP {
+ op = ssa.OpSliceCap
+ }
+ return s.newValue1(op, Types[TINT], s.expr(n.Left))
+ case n.Left.Type.IsString(): // string; not reachable for OCAP
+ return s.newValue1(ssa.OpStringLen, Types[TINT], s.expr(n.Left))
+ case n.Left.Type.IsMap(), n.Left.Type.IsChan():
+ return s.referenceTypeBuiltin(n, s.expr(n.Left))
+ default: // array
+ return s.constInt(Types[TINT], n.Left.Type.Bound)
+ }
+
+ case OSPTR:
+ a := s.expr(n.Left)
+ if n.Left.Type.IsSlice() {
+ return s.newValue1(ssa.OpSlicePtr, n.Type, a)
+ } else {
+ return s.newValue1(ssa.OpStringPtr, n.Type, a)
+ }
+
+ case OITAB:
+ a := s.expr(n.Left)
+ return s.newValue1(ssa.OpITab, n.Type, a)
+
+ case OEFACE:
+ tab := s.expr(n.Left)
+ data := s.expr(n.Right)
+ // The frontend allows putting things like struct{*byte} in
+ // the data portion of an eface. But we don't want struct{*byte}
+ // as a register type because (among other reasons) the liveness
+ // analysis is confused by the "fat" variables that result from
+ // such types being spilled.
+ // So here we ensure that we are selecting the underlying pointer
+ // when we build an eface.
+ // TODO: get rid of this now that structs can be SSA'd?
+ for !data.Type.IsPtr() {
+ switch {
+ case data.Type.IsArray():
+ data = s.newValue2(ssa.OpArrayIndex, data.Type.Elem(), data, s.constInt(Types[TINT], 0))
+ case data.Type.IsStruct():
+ for i := data.Type.NumFields() - 1; i >= 0; i-- {
+ f := data.Type.FieldType(i)
+ if f.Size() == 0 {
+ // eface type could also be struct{p *byte; q [0]int}
+ continue
+ }
+ data = s.newValue1I(ssa.OpStructSelect, f, i, data)
+ break
+ }
+ default:
+ s.Fatalf("type being put into an eface isn't a pointer")
+ }
+ }
+ return s.newValue2(ssa.OpIMake, n.Type, tab, data)
+
+ case OSLICE, OSLICEARR:
+ v := s.expr(n.Left)
+ var i, j *ssa.Value
+ if n.Right.Left != nil {
+ i = s.extendIndex(s.expr(n.Right.Left))
+ }
+ if n.Right.Right != nil {
+ j = s.extendIndex(s.expr(n.Right.Right))
+ }
+ p, l, c := s.slice(n.Left.Type, v, i, j, nil)
+ return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
+ case OSLICESTR:
+ v := s.expr(n.Left)
+ var i, j *ssa.Value
+ if n.Right.Left != nil {
+ i = s.extendIndex(s.expr(n.Right.Left))
+ }
+ if n.Right.Right != nil {
+ j = s.extendIndex(s.expr(n.Right.Right))
+ }
+ p, l, _ := s.slice(n.Left.Type, v, i, j, nil)
+ return s.newValue2(ssa.OpStringMake, n.Type, p, l)
+ case OSLICE3, OSLICE3ARR:
+ v := s.expr(n.Left)
+ var i *ssa.Value
+ if n.Right.Left != nil {
+ i = s.extendIndex(s.expr(n.Right.Left))
+ }
+ j := s.extendIndex(s.expr(n.Right.Right.Left))
+ k := s.extendIndex(s.expr(n.Right.Right.Right))
+ p, l, c := s.slice(n.Left.Type, v, i, j, k)
+ return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
+
+ case OCALLFUNC, OCALLINTER, OCALLMETH:
+ a := s.call(n, callNormal)
+ return s.newValue2(ssa.OpLoad, n.Type, a, s.mem())
+
+ case OGETG:
+ return s.newValue1(ssa.OpGetG, n.Type, s.mem())
+
+ case OAPPEND:
+ // append(s, e1, e2, e3). Compile like:
+ // ptr,len,cap := s
+ // newlen := len + 3
+ // if newlen > s.cap {
+ // ptr,_,cap = growslice(s, newlen)
+ // }
+ // *(ptr+len) = e1
+ // *(ptr+len+1) = e2
+ // *(ptr+len+2) = e3
+ // makeslice(ptr,newlen,cap)
+
+ et := n.Type.Type
+ pt := Ptrto(et)
+
+ // Evaluate slice
+ slice := s.expr(n.List.N)
+
+ // Allocate new blocks
+ grow := s.f.NewBlock(ssa.BlockPlain)
+ assign := s.f.NewBlock(ssa.BlockPlain)
+
+ // Decide if we need to grow
+ nargs := int64(count(n.List) - 1)
+ p := s.newValue1(ssa.OpSlicePtr, pt, slice)
+ l := s.newValue1(ssa.OpSliceLen, Types[TINT], slice)
+ c := s.newValue1(ssa.OpSliceCap, Types[TINT], slice)
+ nl := s.newValue2(s.ssaOp(OADD, Types[TINT]), Types[TINT], l, s.constInt(Types[TINT], nargs))
+ cmp := s.newValue2(s.ssaOp(OGT, Types[TINT]), Types[TBOOL], nl, c)
+ s.vars[&ptrVar] = p
+ s.vars[&capVar] = c
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Likely = ssa.BranchUnlikely
+ b.Control = cmp
+ b.AddEdgeTo(grow)
+ b.AddEdgeTo(assign)
+
+ // Call growslice
+ s.startBlock(grow)
+ taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(n.Type)}, s.sb)
+
+ r := s.rtcall(growslice, true, []*Type{pt, Types[TINT], Types[TINT]}, taddr, p, l, c, nl)
+
+ s.vars[&ptrVar] = r[0]
+ // Note: we don't need to read r[1], the result's length. It will be nl.
+ // (or maybe we should, we just have to spill/restore nl otherwise?)
+ s.vars[&capVar] = r[2]
+ b = s.endBlock()
+ b.AddEdgeTo(assign)
+
+ // assign new elements to slots
+ s.startBlock(assign)
+
+ // Evaluate args
+ args := make([]*ssa.Value, 0, nargs)
+ store := make([]bool, 0, nargs)
+ for l := n.List.Next; l != nil; l = l.Next {
+ if canSSAType(l.N.Type) {
+ args = append(args, s.expr(l.N))
+ store = append(store, true)
+ } else {
+ args = append(args, s.addr(l.N, false))
+ store = append(store, false)
+ }
+ }
+
+ p = s.variable(&ptrVar, pt) // generates phi for ptr
+ c = s.variable(&capVar, Types[TINT]) // generates phi for cap
+ p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l)
+ // TODO: just one write barrier call for all of these writes?
+ // TODO: maybe just one writeBarrier.enabled check?
+ for i, arg := range args {
+ addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TINT], int64(i)))
+ if store[i] {
+ if haspointers(et) {
+ s.insertWBstore(et, addr, arg, n.Lineno)
+ } else {
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem())
+ }
+ } else {
+ if haspointers(et) {
+ s.insertWBmove(et, addr, arg, n.Lineno)
+ } else {
+ s.vars[&memVar] = s.newValue3I(ssa.OpMove, ssa.TypeMem, et.Size(), addr, arg, s.mem())
+ }
+ }
+ }
+
+ // make result
+ delete(s.vars, &ptrVar)
+ delete(s.vars, &capVar)
+ return s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c)
+
+ default:
+ s.Unimplementedf("unhandled expr %s", opnames[n.Op])
+ return nil
+ }
+}
+
+// condBranch evaluates the boolean expression cond and branches to yes
+// if cond is true and no if cond is false.
+// This function is intended to handle && and || better than just calling
+// s.expr(cond) and branching on the result.
+func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
+ if cond.Op == OANDAND {
+ mid := s.f.NewBlock(ssa.BlockPlain)
+ s.stmtList(cond.Ninit)
+ s.condBranch(cond.Left, mid, no, max8(likely, 0))
+ s.startBlock(mid)
+ s.condBranch(cond.Right, yes, no, likely)
+ return
+ // Note: if likely==1, then both recursive calls pass 1.
+ // If likely==-1, then we don't have enough information to decide
+ // whether the first branch is likely or not. So we pass 0 for
+ // the likeliness of the first branch.
+ // TODO: have the frontend give us branch prediction hints for
+ // OANDAND and OOROR nodes (if it ever has such info).
+ }
+ if cond.Op == OOROR {
+ mid := s.f.NewBlock(ssa.BlockPlain)
+ s.stmtList(cond.Ninit)
+ s.condBranch(cond.Left, yes, mid, min8(likely, 0))
+ s.startBlock(mid)
+ s.condBranch(cond.Right, yes, no, likely)
+ return
+ // Note: if likely==-1, then both recursive calls pass -1.
+ // If likely==1, then we don't have enough info to decide
+ // the likelihood of the first branch.
+ }
+ if cond.Op == ONOT {
+ s.stmtList(cond.Ninit)
+ s.condBranch(cond.Left, no, yes, -likely)
+ return
+ }
+ c := s.expr(cond)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = c
+ b.Likely = ssa.BranchPrediction(likely) // gc and ssa both use -1/0/+1 for likeliness
+ b.AddEdgeTo(yes)
+ b.AddEdgeTo(no)
+}
+
+// assign does left = right.
+// Right has already been evaluated to ssa, left has not.
+// If deref is true, then we do left = *right instead (and right has already been nil-checked).
+// If deref is true and right == nil, just do left = 0.
+// Include a write barrier if wb is true.
+func (s *state) assign(left *Node, right *ssa.Value, wb, deref bool, line int32) {
+ if left.Op == ONAME && isblank(left) {
+ return
+ }
+ t := left.Type
+ dowidth(t)
+ if s.canSSA(left) {
+ if deref {
+ s.Fatalf("can SSA LHS %s but not RHS %s", left, right)
+ }
+ if left.Op == ODOT {
+ // We're assigning to a field of an ssa-able value.
+ // We need to build a new structure with the new value for the
+ // field we're assigning and the old values for the other fields.
+ // For instance:
+ // type T struct {a, b, c int}
+ // var T x
+ // x.b = 5
+ // For the x.b = 5 assignment we want to generate x = T{x.a, 5, x.c}
+
+ // Grab information about the structure type.
+ t := left.Left.Type
+ nf := t.NumFields()
+ idx := fieldIdx(left)
+
+ // Grab old value of structure.
+ old := s.expr(left.Left)
+
+ // Make new structure.
+ new := s.newValue0(ssa.StructMakeOp(t.NumFields()), t)
+
+ // Add fields as args.
+ for i := int64(0); i < nf; i++ {
+ if i == idx {
+ new.AddArg(right)
+ } else {
+ new.AddArg(s.newValue1I(ssa.OpStructSelect, t.FieldType(i), i, old))
+ }
+ }
+
+ // Recursively assign the new value we've made to the base of the dot op.
+ s.assign(left.Left, new, false, false, line)
+ // TODO: do we need to update named values here?
+ return
+ }
+ // Update variable assignment.
+ s.vars[left] = right
+ s.addNamedValue(left, right)
+ return
+ }
+ // Left is not ssa-able. Compute its address.
+ addr := s.addr(left, false)
+ if left.Op == ONAME {
+ s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem())
+ }
+ if deref {
+ // Treat as a mem->mem move.
+ if right == nil {
+ s.vars[&memVar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem())
+ return
+ }
+ if wb {
+ s.insertWBmove(t, addr, right, line)
+ return
+ }
+ s.vars[&memVar] = s.newValue3I(ssa.OpMove, ssa.TypeMem, t.Size(), addr, right, s.mem())
+ return
+ }
+ // Treat as a store.
+ if wb {
+ s.insertWBstore(t, addr, right, line)
+ return
+ }
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem())
+}
+
+// zeroVal returns the zero value for type t.
+func (s *state) zeroVal(t *Type) *ssa.Value {
+ switch {
+ case t.IsInteger():
+ switch t.Size() {
+ case 1:
+ return s.constInt8(t, 0)
+ case 2:
+ return s.constInt16(t, 0)
+ case 4:
+ return s.constInt32(t, 0)
+ case 8:
+ return s.constInt64(t, 0)
+ default:
+ s.Fatalf("bad sized integer type %s", t)
+ }
+ case t.IsFloat():
+ switch t.Size() {
+ case 4:
+ return s.constFloat32(t, 0)
+ case 8:
+ return s.constFloat64(t, 0)
+ default:
+ s.Fatalf("bad sized float type %s", t)
+ }
+ case t.IsComplex():
+ switch t.Size() {
+ case 8:
+ z := s.constFloat32(Types[TFLOAT32], 0)
+ return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
+ case 16:
+ z := s.constFloat64(Types[TFLOAT64], 0)
+ return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
+ default:
+ s.Fatalf("bad sized complex type %s", t)
+ }
+
+ case t.IsString():
+ return s.entryNewValue0A(ssa.OpConstString, t, "")
+ case t.IsPtr():
+ return s.entryNewValue0(ssa.OpConstNil, t)
+ case t.IsBoolean():
+ return s.constBool(false)
+ case t.IsInterface():
+ return s.entryNewValue0(ssa.OpConstInterface, t)
+ case t.IsSlice():
+ return s.entryNewValue0(ssa.OpConstSlice, t)
+ case t.IsStruct():
+ n := t.NumFields()
+ v := s.entryNewValue0(ssa.StructMakeOp(t.NumFields()), t)
+ for i := int64(0); i < n; i++ {
+ v.AddArg(s.zeroVal(t.FieldType(i).(*Type)))
+ }
+ return v
+ }
+ s.Unimplementedf("zero for type %v not implemented", t)
+ return nil
+}
+
+type callKind int8
+
+const (
+ callNormal callKind = iota
+ callDefer
+ callGo
+)
+
+// Calls the function n using the specified call type.
+// Returns the address of the return value (or nil if none).
+func (s *state) call(n *Node, k callKind) *ssa.Value {
+ var sym *Sym // target symbol (if static)
+ var closure *ssa.Value // ptr to closure to run (if dynamic)
+ var codeptr *ssa.Value // ptr to target code (if dynamic)
+ var rcvr *ssa.Value // receiver to set
+ fn := n.Left
+ switch n.Op {
+ case OCALLFUNC:
+ if k == callNormal && fn.Op == ONAME && fn.Class == PFUNC {
+ sym = fn.Sym
+ break
+ }
+ closure = s.expr(fn)
+ case OCALLMETH:
+ if fn.Op != ODOTMETH {
+ Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
+ }
+ if fn.Right.Op != ONAME {
+ Fatalf("OCALLMETH: n.Left.Right not a ONAME: %v", fn.Right)
+ }
+ if k == callNormal {
+ sym = fn.Right.Sym
+ break
+ }
+ n2 := *fn.Right
+ n2.Class = PFUNC
+ closure = s.expr(&n2)
+ // Note: receiver is already assigned in n.List, so we don't
+ // want to set it here.
+ case OCALLINTER:
+ if fn.Op != ODOTINTER {
+ Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", Oconv(int(fn.Op), 0))
+ }
+ i := s.expr(fn.Left)
+ itab := s.newValue1(ssa.OpITab, Types[TUINTPTR], i)
+ itabidx := fn.Xoffset + 3*int64(Widthptr) + 8 // offset of fun field in runtime.itab
+ itab = s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], itabidx, itab)
+ if k == callNormal {
+ codeptr = s.newValue2(ssa.OpLoad, Types[TUINTPTR], itab, s.mem())
+ } else {
+ closure = itab
+ }
+ rcvr = s.newValue1(ssa.OpIData, Types[TUINTPTR], i)
+ }
+ dowidth(fn.Type)
+ stksize := fn.Type.Argwid // includes receiver
+
+ // Run all argument assignments. The arg slots have already
+ // been offset by the appropriate amount (+2*widthptr for go/defer,
+ // +widthptr for interface calls).
+ // For OCALLMETH, the receiver is set in these statements.
+ s.stmtList(n.List)
+
+ // Set receiver (for interface calls)
+ if rcvr != nil {
+ argStart := Ctxt.FixedFrameSize()
+ if k != callNormal {
+ argStart += int64(2 * Widthptr)
+ }
+ addr := s.entryNewValue1I(ssa.OpOffPtr, Types[TUINTPTR], argStart, s.sp)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, rcvr, s.mem())
+ }
+
+ // Defer/go args
+ if k != callNormal {
+ // Write argsize and closure (args to Newproc/Deferproc).
+ argsize := s.constInt32(Types[TUINT32], int32(stksize))
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem())
+ addr := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(Types[TUINTPTR]), int64(Widthptr), s.sp)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, closure, s.mem())
+ stksize += 2 * int64(Widthptr)
+ }
+
+ // call target
+ bNext := s.f.NewBlock(ssa.BlockPlain)
+ var call *ssa.Value
+ switch {
+ case k == callDefer:
+ call = s.newValue1(ssa.OpDeferCall, ssa.TypeMem, s.mem())
+ case k == callGo:
+ call = s.newValue1(ssa.OpGoCall, ssa.TypeMem, s.mem())
+ case closure != nil:
+ codeptr = s.newValue2(ssa.OpLoad, Types[TUINTPTR], closure, s.mem())
+ call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, codeptr, closure, s.mem())
+ case codeptr != nil:
+ call = s.newValue2(ssa.OpInterCall, ssa.TypeMem, codeptr, s.mem())
+ case sym != nil:
+ call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, sym, s.mem())
+ default:
+ Fatalf("bad call type %s %v", opnames[n.Op], n)
+ }
+ call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
+
+ // Finish call block
+ s.vars[&memVar] = call
+ b := s.endBlock()
+ b.Kind = ssa.BlockCall
+ b.Control = call
+ b.AddEdgeTo(bNext)
+
+ // Start exit block, find address of result.
+ s.startBlock(bNext)
+ var titer Iter
+ fp := Structfirst(&titer, Getoutarg(n.Left.Type))
+ if fp == nil || k != callNormal {
+ // call has no return value. Continue with the next statement.
+ return nil
+ }
+ return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp)
+}
+
+// etypesign returns the signed-ness of e, for integer/pointer etypes.
+// -1 means signed, +1 means unsigned, 0 means non-integer/non-pointer.
+func etypesign(e EType) int8 {
+ switch e {
+ case TINT8, TINT16, TINT32, TINT64, TINT:
+ return -1
+ case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR, TUNSAFEPTR:
+ return +1
+ }
+ return 0
+}
+
+// lookupSymbol is used to retrieve the symbol (Extern, Arg or Auto) used for a particular node.
+// This improves the effectiveness of cse by using the same Aux values for the
+// same symbols.
+func (s *state) lookupSymbol(n *Node, sym interface{}) interface{} {
+ switch sym.(type) {
+ default:
+ s.Fatalf("sym %v is of uknown type %T", sym, sym)
+ case *ssa.ExternSymbol, *ssa.ArgSymbol, *ssa.AutoSymbol:
+ // these are the only valid types
+ }
+
+ if lsym, ok := s.varsyms[n]; ok {
+ return lsym
+ } else {
+ s.varsyms[n] = sym
+ return sym
+ }
+}
+
+// addr converts the address of the expression n to SSA, adds it to s and returns the SSA result.
+// The value that the returned Value represents is guaranteed to be non-nil.
+// If bounded is true then this address does not require a nil check for its operand
+// even if that would otherwise be implied.
+func (s *state) addr(n *Node, bounded bool) *ssa.Value {
+ t := Ptrto(n.Type)
+ switch n.Op {
+ case ONAME:
+ switch n.Class {
+ case PEXTERN:
+ // global variable
+ aux := s.lookupSymbol(n, &ssa.ExternSymbol{n.Type, n.Sym})
+ v := s.entryNewValue1A(ssa.OpAddr, t, aux, s.sb)
+ // TODO: Make OpAddr use AuxInt as well as Aux.
+ if n.Xoffset != 0 {
+ v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v)
+ }
+ return v
+ case PPARAM:
+ // parameter slot
+ v := s.decladdrs[n]
+ if v != nil {
+ return v
+ }
+ if n.String() == ".fp" {
+ // Special arg that points to the frame pointer.
+ // (Used by the race detector, others?)
+ aux := s.lookupSymbol(n, &ssa.ArgSymbol{Typ: n.Type, Node: n})
+ return s.entryNewValue1A(ssa.OpAddr, t, aux, s.sp)
+ }
+ s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
+ return nil
+ case PAUTO:
+ // We need to regenerate the address of autos
+ // at every use. This prevents LEA instructions
+ // from occurring before the corresponding VarDef
+ // op and confusing the liveness analysis into thinking
+ // the variable is live at function entry.
+ // TODO: I'm not sure if this really works or we're just
+ // getting lucky. We might need a real dependency edge
+ // between vardef and addr ops.
+ aux := &ssa.AutoSymbol{Typ: n.Type, Node: n}
+ return s.newValue1A(ssa.OpAddr, t, aux, s.sp)
+ case PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
+ // ensure that we reuse symbols for out parameters so
+ // that cse works on their addresses
+ aux := s.lookupSymbol(n, &ssa.ArgSymbol{Typ: n.Type, Node: n})
+ return s.newValue1A(ssa.OpAddr, t, aux, s.sp)
+ case PAUTO | PHEAP, PPARAM | PHEAP, PPARAMOUT | PHEAP, PPARAMREF:
+ return s.expr(n.Name.Heapaddr)
+ default:
+ s.Unimplementedf("variable address class %v not implemented", n.Class)
+ return nil
+ }
+ case OINDREG:
+ // indirect off a register
+ // used for storing/loading arguments/returns to/from callees
+ if int(n.Reg) != Thearch.REGSP {
+ s.Unimplementedf("OINDREG of non-SP register %s in addr: %v", obj.Rconv(int(n.Reg)), n)
+ return nil
+ }
+ return s.entryNewValue1I(ssa.OpOffPtr, t, n.Xoffset, s.sp)
+ case OINDEX:
+ if n.Left.Type.IsSlice() {
+ a := s.expr(n.Left)
+ i := s.expr(n.Right)
+ i = s.extendIndex(i)
+ len := s.newValue1(ssa.OpSliceLen, Types[TINT], a)
+ if !n.Bounded {
+ s.boundsCheck(i, len)
+ }
+ p := s.newValue1(ssa.OpSlicePtr, t, a)
+ return s.newValue2(ssa.OpPtrIndex, t, p, i)
+ } else { // array
+ a := s.addr(n.Left, bounded)
+ i := s.expr(n.Right)
+ i = s.extendIndex(i)
+ len := s.constInt(Types[TINT], n.Left.Type.Bound)
+ if !n.Bounded {
+ s.boundsCheck(i, len)
+ }
+ return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i)
+ }
+ case OIND:
+ p := s.expr(n.Left)
+ if !bounded {
+ s.nilCheck(p)
+ }
+ return p
+ case ODOT:
+ p := s.addr(n.Left, bounded)
+ return s.newValue2(ssa.OpAddPtr, t, p, s.constInt(Types[TINT], n.Xoffset))
+ case ODOTPTR:
+ p := s.expr(n.Left)
+ if !bounded {
+ s.nilCheck(p)
+ }
+ return s.newValue2(ssa.OpAddPtr, t, p, s.constInt(Types[TINT], n.Xoffset))
+ case OCLOSUREVAR:
+ return s.newValue2(ssa.OpAddPtr, t,
+ s.entryNewValue0(ssa.OpGetClosurePtr, Ptrto(Types[TUINT8])),
+ s.constInt(Types[TINT], n.Xoffset))
+ case OPARAM:
+ p := n.Left
+ if p.Op != ONAME || !(p.Class == PPARAM|PHEAP || p.Class == PPARAMOUT|PHEAP) {
+ s.Fatalf("OPARAM not of ONAME,{PPARAM,PPARAMOUT}|PHEAP, instead %s", nodedump(p, 0))
+ }
+
+ // Recover original offset to address passed-in param value.
+ original_p := *p
+ original_p.Xoffset = n.Xoffset
+ aux := &ssa.ArgSymbol{Typ: n.Type, Node: &original_p}
+ return s.entryNewValue1A(ssa.OpAddr, t, aux, s.sp)
+ case OCONVNOP:
+ addr := s.addr(n.Left, bounded)
+ return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
+ case OCALLFUNC, OCALLINTER, OCALLMETH:
+ return s.call(n, callNormal)
+
+ default:
+ s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0))
+ return nil
+ }
+}
+
+// canSSA reports whether n is SSA-able.
+// n must be an ONAME (or an ODOT sequence with an ONAME base).
+func (s *state) canSSA(n *Node) bool {
+ for n.Op == ODOT {
+ n = n.Left
+ }
+ if n.Op != ONAME {
+ return false
+ }
+ if n.Addrtaken {
+ return false
+ }
+ if n.Class&PHEAP != 0 {
+ return false
+ }
+ switch n.Class {
+ case PEXTERN, PPARAMREF:
+ // TODO: maybe treat PPARAMREF with an Arg-like op to read from closure?
+ return false
+ case PPARAMOUT:
+ if hasdefer {
+ // TODO: handle this case? Named return values must be
+ // in memory so that the deferred function can see them.
+ // Maybe do: if !strings.HasPrefix(n.String(), "~") { return false }
+ return false
+ }
+ if s.cgoUnsafeArgs {
+ // Cgo effectively takes the address of all result args,
+ // but the compiler can't see that.
+ return false
+ }
+ }
+ if n.Class == PPARAM && n.String() == ".this" {
+ // wrappers generated by genwrapper need to update
+ // the .this pointer in place.
+ // TODO: treat as a PPARMOUT?
+ return false
+ }
+ return canSSAType(n.Type)
+ // TODO: try to make more variables SSAable?
+}
+
+// canSSA reports whether variables of type t are SSA-able.
+func canSSAType(t *Type) bool {
+ dowidth(t)
+ if t.Width > int64(4*Widthptr) {
+ // 4*Widthptr is an arbitrary constant. We want it
+ // to be at least 3*Widthptr so slices can be registerized.
+ // Too big and we'll introduce too much register pressure.
+ return false
+ }
+ switch t.Etype {
+ case TARRAY:
+ if Isslice(t) {
+ return true
+ }
+ // We can't do arrays because dynamic indexing is
+ // not supported on SSA variables.
+ // TODO: maybe allow if length is <=1? All indexes
+ // are constant? Might be good for the arrays
+ // introduced by the compiler for variadic functions.
+ return false
+ case TSTRUCT:
+ if countfield(t) > ssa.MaxStruct {
+ return false
+ }
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
+ if !canSSAType(t1.Type) {
+ return false
+ }
+ }
+ return true
+ default:
+ return true
+ }
+}
+
+// nilCheck generates nil pointer checking code.
+// Starts a new block on return, unless nil checks are disabled.
+// Used only for automatically inserted nil checks,
+// not for user code like 'x != nil'.
+func (s *state) nilCheck(ptr *ssa.Value) {
+ if Disable_checknil != 0 {
+ return
+ }
+ chk := s.newValue2(ssa.OpNilCheck, ssa.TypeVoid, ptr, s.mem())
+ b := s.endBlock()
+ b.Kind = ssa.BlockCheck
+ b.Control = chk
+ bNext := s.f.NewBlock(ssa.BlockPlain)
+ b.AddEdgeTo(bNext)
+ s.startBlock(bNext)
+}
+
+// boundsCheck generates bounds checking code. Checks if 0 <= idx < len, branches to exit if not.
+// Starts a new block on return.
+func (s *state) boundsCheck(idx, len *ssa.Value) {
+ if Debug['B'] != 0 {
+ return
+ }
+ // TODO: convert index to full width?
+ // TODO: if index is 64-bit and we're compiling to 32-bit, check that high 32 bits are zero.
+
+ // bounds check
+ cmp := s.newValue2(ssa.OpIsInBounds, Types[TBOOL], idx, len)
+ s.check(cmp, Panicindex)
+}
+
+// sliceBoundsCheck generates slice bounds checking code. Checks if 0 <= idx <= len, branches to exit if not.
+// Starts a new block on return.
+func (s *state) sliceBoundsCheck(idx, len *ssa.Value) {
+ if Debug['B'] != 0 {
+ return
+ }
+ // TODO: convert index to full width?
+ // TODO: if index is 64-bit and we're compiling to 32-bit, check that high 32 bits are zero.
+
+ // bounds check
+ cmp := s.newValue2(ssa.OpIsSliceInBounds, Types[TBOOL], idx, len)
+ s.check(cmp, panicslice)
+}
+
+// If cmp (a bool) is true, panic using the given function.
+func (s *state) check(cmp *ssa.Value, fn *Node) {
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = cmp
+ b.Likely = ssa.BranchLikely
+ bNext := s.f.NewBlock(ssa.BlockPlain)
+ line := s.peekLine()
+ bPanic := s.panics[funcLine{fn, line}]
+ if bPanic == nil {
+ bPanic = s.f.NewBlock(ssa.BlockPlain)
+ s.panics[funcLine{fn, line}] = bPanic
+ s.startBlock(bPanic)
+ // The panic call takes/returns memory to ensure that the right
+ // memory state is observed if the panic happens.
+ s.rtcall(fn, false, nil)
+ }
+ b.AddEdgeTo(bNext)
+ b.AddEdgeTo(bPanic)
+ s.startBlock(bNext)
+}
+
+// rtcall issues a call to the given runtime function fn with the listed args.
+// Returns a slice of results of the given result types.
+// The call is added to the end of the current block.
+// If returns is false, the block is marked as an exit block.
+// If returns is true, the block is marked as a call block. A new block
+// is started to load the return values.
+func (s *state) rtcall(fn *Node, returns bool, results []*Type, args ...*ssa.Value) []*ssa.Value {
+ // Write args to the stack
+ var off int64 // TODO: arch-dependent starting offset?
+ for _, arg := range args {
+ t := arg.Type
+ off = Rnd(off, t.Alignment())
+ ptr := s.sp
+ if off != 0 {
+ ptr = s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], off, s.sp)
+ }
+ size := t.Size()
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, size, ptr, arg, s.mem())
+ off += size
+ }
+ off = Rnd(off, int64(Widthptr))
+
+ // Issue call
+ call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, fn.Sym, s.mem())
+ s.vars[&memVar] = call
+
+ // Finish block
+ b := s.endBlock()
+ if !returns {
+ b.Kind = ssa.BlockExit
+ b.Control = call
+ call.AuxInt = off
+ if len(results) > 0 {
+ Fatalf("panic call can't have results")
+ }
+ return nil
+ }
+ b.Kind = ssa.BlockCall
+ b.Control = call
+ bNext := s.f.NewBlock(ssa.BlockPlain)
+ b.AddEdgeTo(bNext)
+ s.startBlock(bNext)
+
+ // Load results
+ res := make([]*ssa.Value, len(results))
+ for i, t := range results {
+ off = Rnd(off, t.Alignment())
+ ptr := s.sp
+ if off != 0 {
+ ptr = s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], off, s.sp)
+ }
+ res[i] = s.newValue2(ssa.OpLoad, t, ptr, s.mem())
+ off += t.Size()
+ }
+ off = Rnd(off, int64(Widthptr))
+
+ // Remember how much callee stack space we needed.
+ call.AuxInt = off
+
+ return res
+}
+
+// insertWBmove inserts the assignment *left = *right including a write barrier.
+// t is the type being assigned.
+func (s *state) insertWBmove(t *Type, left, right *ssa.Value, line int32) {
+ // if writeBarrier.enabled {
+ // typedmemmove(&t, left, right)
+ // } else {
+ // *left = *right
+ // }
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bElse := s.f.NewBlock(ssa.BlockPlain)
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrier", 0).Sym}
+ flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TUINT32]), aux, s.sb)
+ // TODO: select the .enabled field. It is currently first, so not needed for now.
+ // Load word, test byte, avoiding partial register write from load byte.
+ flag := s.newValue2(ssa.OpLoad, Types[TUINT32], flagaddr, s.mem())
+ flag = s.newValue1(ssa.OpTrunc64to8, Types[TBOOL], flag)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Likely = ssa.BranchUnlikely
+ b.Control = flag
+ b.AddEdgeTo(bThen)
+ b.AddEdgeTo(bElse)
+
+ s.startBlock(bThen)
+ taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb)
+ s.rtcall(typedmemmove, true, nil, taddr, left, right)
+ s.endBlock().AddEdgeTo(bEnd)
+
+ s.startBlock(bElse)
+ s.vars[&memVar] = s.newValue3I(ssa.OpMove, ssa.TypeMem, t.Size(), left, right, s.mem())
+ s.endBlock().AddEdgeTo(bEnd)
+
+ s.startBlock(bEnd)
+
+ if Debug_wb > 0 {
+ Warnl(int(line), "write barrier")
+ }
+}
+
+// insertWBstore inserts the assignment *left = right including a write barrier.
+// t is the type being assigned.
+func (s *state) insertWBstore(t *Type, left, right *ssa.Value, line int32) {
+ // store scalar fields
+ // if writeBarrier.enabled {
+ // writebarrierptr for pointer fields
+ // } else {
+ // store pointer fields
+ // }
+
+ s.storeTypeScalars(t, left, right)
+
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bElse := s.f.NewBlock(ssa.BlockPlain)
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrier", 0).Sym}
+ flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TUINT32]), aux, s.sb)
+ // TODO: select the .enabled field. It is currently first, so not needed for now.
+ // Load word, test byte, avoiding partial register write from load byte.
+ flag := s.newValue2(ssa.OpLoad, Types[TUINT32], flagaddr, s.mem())
+ flag = s.newValue1(ssa.OpTrunc64to8, Types[TBOOL], flag)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Likely = ssa.BranchUnlikely
+ b.Control = flag
+ b.AddEdgeTo(bThen)
+ b.AddEdgeTo(bElse)
+
+ // Issue write barriers for pointer writes.
+ s.startBlock(bThen)
+ s.storeTypePtrsWB(t, left, right)
+ s.endBlock().AddEdgeTo(bEnd)
+
+ // Issue regular stores for pointer writes.
+ s.startBlock(bElse)
+ s.storeTypePtrs(t, left, right)
+ s.endBlock().AddEdgeTo(bEnd)
+
+ s.startBlock(bEnd)
+
+ if Debug_wb > 0 {
+ Warnl(int(line), "write barrier")
+ }
+}
+
+// do *left = right for all scalar (non-pointer) parts of t.
+func (s *state) storeTypeScalars(t *Type, left, right *ssa.Value) {
+ switch {
+ case t.IsBoolean() || t.IsInteger() || t.IsFloat() || t.IsComplex():
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), left, right, s.mem())
+ case t.IsPtr() || t.IsMap() || t.IsChan():
+ // no scalar fields.
+ case t.IsString():
+ len := s.newValue1(ssa.OpStringLen, Types[TINT], right)
+ lenAddr := s.newValue1I(ssa.OpOffPtr, Ptrto(Types[TINT]), s.config.IntSize, left)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, lenAddr, len, s.mem())
+ case t.IsSlice():
+ len := s.newValue1(ssa.OpSliceLen, Types[TINT], right)
+ cap := s.newValue1(ssa.OpSliceCap, Types[TINT], right)
+ lenAddr := s.newValue1I(ssa.OpOffPtr, Ptrto(Types[TINT]), s.config.IntSize, left)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, lenAddr, len, s.mem())
+ capAddr := s.newValue1I(ssa.OpOffPtr, Ptrto(Types[TINT]), 2*s.config.IntSize, left)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, capAddr, cap, s.mem())
+ case t.IsInterface():
+ // itab field doesn't need a write barrier (even though it is a pointer).
+ itab := s.newValue1(ssa.OpITab, Ptrto(Types[TUINT8]), right)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, left, itab, s.mem())
+ case t.IsStruct():
+ n := t.NumFields()
+ for i := int64(0); i < n; i++ {
+ ft := t.FieldType(i)
+ addr := s.newValue1I(ssa.OpOffPtr, ft.PtrTo(), t.FieldOff(i), left)
+ val := s.newValue1I(ssa.OpStructSelect, ft, i, right)
+ s.storeTypeScalars(ft.(*Type), addr, val)
+ }
+ default:
+ s.Fatalf("bad write barrier type %s", t)
+ }
+}
+
+// do *left = right for all pointer parts of t.
+func (s *state) storeTypePtrs(t *Type, left, right *ssa.Value) {
+ switch {
+ case t.IsPtr() || t.IsMap() || t.IsChan():
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, right, s.mem())
+ case t.IsString():
+ ptr := s.newValue1(ssa.OpStringPtr, Ptrto(Types[TUINT8]), right)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, ptr, s.mem())
+ case t.IsSlice():
+ ptr := s.newValue1(ssa.OpSlicePtr, Ptrto(Types[TUINT8]), right)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, ptr, s.mem())
+ case t.IsInterface():
+ // itab field is treated as a scalar.
+ idata := s.newValue1(ssa.OpIData, Ptrto(Types[TUINT8]), right)
+ idataAddr := s.newValue1I(ssa.OpOffPtr, Ptrto(Types[TUINT8]), s.config.PtrSize, left)
+ s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, idataAddr, idata, s.mem())
+ case t.IsStruct():
+ n := t.NumFields()
+ for i := int64(0); i < n; i++ {
+ ft := t.FieldType(i)
+ if !haspointers(ft.(*Type)) {
+ continue
+ }
+ addr := s.newValue1I(ssa.OpOffPtr, ft.PtrTo(), t.FieldOff(i), left)
+ val := s.newValue1I(ssa.OpStructSelect, ft, i, right)
+ s.storeTypePtrs(ft.(*Type), addr, val)
+ }
+ default:
+ s.Fatalf("bad write barrier type %s", t)
+ }
+}
+
+// do *left = right with a write barrier for all pointer parts of t.
+func (s *state) storeTypePtrsWB(t *Type, left, right *ssa.Value) {
+ switch {
+ case t.IsPtr() || t.IsMap() || t.IsChan():
+ s.rtcall(writebarrierptr, true, nil, left, right)
+ case t.IsString():
+ ptr := s.newValue1(ssa.OpStringPtr, Ptrto(Types[TUINT8]), right)
+ s.rtcall(writebarrierptr, true, nil, left, ptr)
+ case t.IsSlice():
+ ptr := s.newValue1(ssa.OpSlicePtr, Ptrto(Types[TUINT8]), right)
+ s.rtcall(writebarrierptr, true, nil, left, ptr)
+ case t.IsInterface():
+ idata := s.newValue1(ssa.OpIData, Ptrto(Types[TUINT8]), right)
+ idataAddr := s.newValue1I(ssa.OpOffPtr, Ptrto(Types[TUINT8]), s.config.PtrSize, left)
+ s.rtcall(writebarrierptr, true, nil, idataAddr, idata)
+ case t.IsStruct():
+ n := t.NumFields()
+ for i := int64(0); i < n; i++ {
+ ft := t.FieldType(i)
+ if !haspointers(ft.(*Type)) {
+ continue
+ }
+ addr := s.newValue1I(ssa.OpOffPtr, ft.PtrTo(), t.FieldOff(i), left)
+ val := s.newValue1I(ssa.OpStructSelect, ft, i, right)
+ s.storeTypePtrsWB(ft.(*Type), addr, val)
+ }
+ default:
+ s.Fatalf("bad write barrier type %s", t)
+ }
+}
+
+// slice computes the slice v[i:j:k] and returns ptr, len, and cap of result.
+// i,j,k may be nil, in which case they are set to their default value.
+// t is a slice, ptr to array, or string type.
+func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) {
+ var elemtype *Type
+ var ptrtype *Type
+ var ptr *ssa.Value
+ var len *ssa.Value
+ var cap *ssa.Value
+ zero := s.constInt(Types[TINT], 0)
+ switch {
+ case t.IsSlice():
+ elemtype = t.Type
+ ptrtype = Ptrto(elemtype)
+ ptr = s.newValue1(ssa.OpSlicePtr, ptrtype, v)
+ len = s.newValue1(ssa.OpSliceLen, Types[TINT], v)
+ cap = s.newValue1(ssa.OpSliceCap, Types[TINT], v)
+ case t.IsString():
+ elemtype = Types[TUINT8]
+ ptrtype = Ptrto(elemtype)
+ ptr = s.newValue1(ssa.OpStringPtr, ptrtype, v)
+ len = s.newValue1(ssa.OpStringLen, Types[TINT], v)
+ cap = len
+ case t.IsPtr():
+ if !t.Type.IsArray() {
+ s.Fatalf("bad ptr to array in slice %v\n", t)
+ }
+ elemtype = t.Type.Type
+ ptrtype = Ptrto(elemtype)
+ s.nilCheck(v)
+ ptr = v
+ len = s.constInt(Types[TINT], t.Type.Bound)
+ cap = len
+ default:
+ s.Fatalf("bad type in slice %v\n", t)
+ }
+
+ // Set default values
+ if i == nil {
+ i = zero
+ }
+ if j == nil {
+ j = len
+ }
+ if k == nil {
+ k = cap
+ }
+
+ // Panic if slice indices are not in bounds.
+ s.sliceBoundsCheck(i, j)
+ if j != k {
+ s.sliceBoundsCheck(j, k)
+ }
+ if k != cap {
+ s.sliceBoundsCheck(k, cap)
+ }
+
+ // Generate the following code assuming that indexes are in bounds.
+ // The conditional is to make sure that we don't generate a slice
+ // that points to the next object in memory.
+ // rlen = (Sub64 j i)
+ // rcap = (Sub64 k i)
+ // p = ptr
+ // if rcap != 0 {
+ // p = (AddPtr ptr (Mul64 low (Const64 size)))
+ // }
+ // result = (SliceMake p size)
+ subOp := s.ssaOp(OSUB, Types[TINT])
+ neqOp := s.ssaOp(ONE, Types[TINT])
+ mulOp := s.ssaOp(OMUL, Types[TINT])
+ rlen := s.newValue2(subOp, Types[TINT], j, i)
+ var rcap *ssa.Value
+ switch {
+ case t.IsString():
+ // Capacity of the result is unimportant. However, we use
+ // rcap to test if we've generated a zero-length slice.
+ // Use length of strings for that.
+ rcap = rlen
+ case j == k:
+ rcap = rlen
+ default:
+ rcap = s.newValue2(subOp, Types[TINT], k, i)
+ }
+
+ s.vars[&ptrVar] = ptr
+
+ // Generate code to test the resulting slice length.
+ cmp := s.newValue2(neqOp, Types[TBOOL], rcap, s.constInt(Types[TINT], 0))
+
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Likely = ssa.BranchLikely
+ b.Control = cmp
+
+ // Generate code for non-zero length slice case.
+ nz := s.f.NewBlock(ssa.BlockPlain)
+ b.AddEdgeTo(nz)
+ s.startBlock(nz)
+ var inc *ssa.Value
+ if elemtype.Width == 1 {
+ inc = i
+ } else {
+ inc = s.newValue2(mulOp, Types[TINT], i, s.constInt(Types[TINT], elemtype.Width))
+ }
+ s.vars[&ptrVar] = s.newValue2(ssa.OpAddPtr, ptrtype, ptr, inc)
+ s.endBlock()
+
+ // All done.
+ merge := s.f.NewBlock(ssa.BlockPlain)
+ b.AddEdgeTo(merge)
+ nz.AddEdgeTo(merge)
+ s.startBlock(merge)
+ rptr := s.variable(&ptrVar, ptrtype)
+ delete(s.vars, &ptrVar)
+ return rptr, rlen, rcap
+}
+
+type u2fcvtTab struct {
+ geq, cvt2F, and, rsh, or, add ssa.Op
+ one func(*state, ssa.Type, int64) *ssa.Value
+}
+
+var u64_f64 u2fcvtTab = u2fcvtTab{
+ geq: ssa.OpGeq64,
+ cvt2F: ssa.OpCvt64to64F,
+ and: ssa.OpAnd64,
+ rsh: ssa.OpRsh64Ux64,
+ or: ssa.OpOr64,
+ add: ssa.OpAdd64F,
+ one: (*state).constInt64,
+}
+
+var u64_f32 u2fcvtTab = u2fcvtTab{
+ geq: ssa.OpGeq64,
+ cvt2F: ssa.OpCvt64to32F,
+ and: ssa.OpAnd64,
+ rsh: ssa.OpRsh64Ux64,
+ or: ssa.OpOr64,
+ add: ssa.OpAdd32F,
+ one: (*state).constInt64,
+}
+
+// Excess generality on a machine with 64-bit integer registers.
+// Not used on AMD64.
+var u32_f32 u2fcvtTab = u2fcvtTab{
+ geq: ssa.OpGeq32,
+ cvt2F: ssa.OpCvt32to32F,
+ and: ssa.OpAnd32,
+ rsh: ssa.OpRsh32Ux32,
+ or: ssa.OpOr32,
+ add: ssa.OpAdd32F,
+ one: func(s *state, t ssa.Type, x int64) *ssa.Value {
+ return s.constInt32(t, int32(x))
+ },
+}
+
+func (s *state) uint64Tofloat64(n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ return s.uintTofloat(&u64_f64, n, x, ft, tt)
+}
+
+func (s *state) uint64Tofloat32(n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ return s.uintTofloat(&u64_f32, n, x, ft, tt)
+}
+
+func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ // if x >= 0 {
+ // result = (floatY) x
+ // } else {
+ // y = uintX(x) ; y = x & 1
+ // z = uintX(x) ; z = z >> 1
+ // z = z >> 1
+ // z = z | y
+ // result = floatY(z)
+ // result = result + result
+ // }
+ //
+ // Code borrowed from old code generator.
+ // What's going on: large 64-bit "unsigned" looks like
+ // negative number to hardware's integer-to-float
+ // conversion. However, because the mantissa is only
+ // 63 bits, we don't need the LSB, so instead we do an
+ // unsigned right shift (divide by two), convert, and
+ // double. However, before we do that, we need to be
+ // sure that we do not lose a "1" if that made the
+ // difference in the resulting rounding. Therefore, we
+ // preserve it, and OR (not ADD) it back in. The case
+ // that matters is when the eleven discarded bits are
+ // equal to 10000000001; that rounds up, and the 1 cannot
+ // be lost else it would round down if the LSB of the
+ // candidate mantissa is 0.
+ cmp := s.newValue2(cvttab.geq, Types[TBOOL], x, s.zeroVal(ft))
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = cmp
+ b.Likely = ssa.BranchLikely
+
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bElse := s.f.NewBlock(ssa.BlockPlain)
+ bAfter := s.f.NewBlock(ssa.BlockPlain)
+
+ b.AddEdgeTo(bThen)
+ s.startBlock(bThen)
+ a0 := s.newValue1(cvttab.cvt2F, tt, x)
+ s.vars[n] = a0
+ s.endBlock()
+ bThen.AddEdgeTo(bAfter)
+
+ b.AddEdgeTo(bElse)
+ s.startBlock(bElse)
+ one := cvttab.one(s, ft, 1)
+ y := s.newValue2(cvttab.and, ft, x, one)
+ z := s.newValue2(cvttab.rsh, ft, x, one)
+ z = s.newValue2(cvttab.or, ft, z, y)
+ a := s.newValue1(cvttab.cvt2F, tt, z)
+ a1 := s.newValue2(cvttab.add, tt, a, a)
+ s.vars[n] = a1
+ s.endBlock()
+ bElse.AddEdgeTo(bAfter)
+
+ s.startBlock(bAfter)
+ return s.variable(n, n.Type)
+}
+
+// referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
+func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
+ if !n.Left.Type.IsMap() && !n.Left.Type.IsChan() {
+ s.Fatalf("node must be a map or a channel")
+ }
+ // if n == nil {
+ // return 0
+ // } else {
+ // // len
+ // return *((*int)n)
+ // // cap
+ // return *(((*int)n)+1)
+ // }
+ lenType := n.Type
+ nilValue := s.newValue0(ssa.OpConstNil, Types[TUINTPTR])
+ cmp := s.newValue2(ssa.OpEqPtr, Types[TBOOL], x, nilValue)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = cmp
+ b.Likely = ssa.BranchUnlikely
+
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bElse := s.f.NewBlock(ssa.BlockPlain)
+ bAfter := s.f.NewBlock(ssa.BlockPlain)
+
+ // length/capacity of a nil map/chan is zero
+ b.AddEdgeTo(bThen)
+ s.startBlock(bThen)
+ s.vars[n] = s.zeroVal(lenType)
+ s.endBlock()
+ bThen.AddEdgeTo(bAfter)
+
+ b.AddEdgeTo(bElse)
+ s.startBlock(bElse)
+ if n.Op == OLEN {
+ // length is stored in the first word for map/chan
+ s.vars[n] = s.newValue2(ssa.OpLoad, lenType, x, s.mem())
+ } else if n.Op == OCAP {
+ // capacity is stored in the second word for chan
+ sw := s.newValue1I(ssa.OpOffPtr, lenType.PtrTo(), lenType.Width, x)
+ s.vars[n] = s.newValue2(ssa.OpLoad, lenType, sw, s.mem())
+ } else {
+ s.Fatalf("op must be OLEN or OCAP")
+ }
+ s.endBlock()
+ bElse.AddEdgeTo(bAfter)
+
+ s.startBlock(bAfter)
+ return s.variable(n, lenType)
+}
+
+type f2uCvtTab struct {
+ ltf, cvt2U, subf ssa.Op
+ value func(*state, ssa.Type, float64) *ssa.Value
+}
+
+var f32_u64 f2uCvtTab = f2uCvtTab{
+ ltf: ssa.OpLess32F,
+ cvt2U: ssa.OpCvt32Fto64,
+ subf: ssa.OpSub32F,
+ value: (*state).constFloat32,
+}
+
+var f64_u64 f2uCvtTab = f2uCvtTab{
+ ltf: ssa.OpLess64F,
+ cvt2U: ssa.OpCvt64Fto64,
+ subf: ssa.OpSub64F,
+ value: (*state).constFloat64,
+}
+
+func (s *state) float32ToUint64(n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ return s.floatToUint(&f32_u64, n, x, ft, tt)
+}
+func (s *state) float64ToUint64(n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ return s.floatToUint(&f64_u64, n, x, ft, tt)
+}
+
+func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *Type) *ssa.Value {
+ // if x < 9223372036854775808.0 {
+ // result = uintY(x)
+ // } else {
+ // y = x - 9223372036854775808.0
+ // z = uintY(y)
+ // result = z | -9223372036854775808
+ // }
+ twoToThe63 := cvttab.value(s, ft, 9223372036854775808.0)
+ cmp := s.newValue2(cvttab.ltf, Types[TBOOL], x, twoToThe63)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = cmp
+ b.Likely = ssa.BranchLikely
+
+ bThen := s.f.NewBlock(ssa.BlockPlain)
+ bElse := s.f.NewBlock(ssa.BlockPlain)
+ bAfter := s.f.NewBlock(ssa.BlockPlain)
+
+ b.AddEdgeTo(bThen)
+ s.startBlock(bThen)
+ a0 := s.newValue1(cvttab.cvt2U, tt, x)
+ s.vars[n] = a0
+ s.endBlock()
+ bThen.AddEdgeTo(bAfter)
+
+ b.AddEdgeTo(bElse)
+ s.startBlock(bElse)
+ y := s.newValue2(cvttab.subf, ft, x, twoToThe63)
+ y = s.newValue1(cvttab.cvt2U, tt, y)
+ z := s.constInt64(tt, -9223372036854775808)
+ a1 := s.newValue2(ssa.OpOr64, tt, y, z)
+ s.vars[n] = a1
+ s.endBlock()
+ bElse.AddEdgeTo(bAfter)
+
+ s.startBlock(bAfter)
+ return s.variable(n, n.Type)
+}
+
+// ifaceType returns the value for the word containing the type.
+// n is the node for the interface expression.
+// v is the corresponding value.
+func (s *state) ifaceType(n *Node, v *ssa.Value) *ssa.Value {
+ byteptr := Ptrto(Types[TUINT8]) // type used in runtime prototypes for runtime type (*byte)
+
+ if isnilinter(n.Type) {
+ // Have *eface. The type is the first word in the struct.
+ return s.newValue1(ssa.OpITab, byteptr, v)
+ }
+
+ // Have *iface.
+ // The first word in the struct is the *itab.
+ // If the *itab is nil, return 0.
+ // Otherwise, the second word in the *itab is the type.
+
+ tab := s.newValue1(ssa.OpITab, byteptr, v)
+ s.vars[&typVar] = tab
+ isnonnil := s.newValue2(ssa.OpNeqPtr, Types[TBOOL], tab, s.entryNewValue0(ssa.OpConstNil, byteptr))
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = isnonnil
+ b.Likely = ssa.BranchLikely
+
+ bLoad := s.f.NewBlock(ssa.BlockPlain)
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ b.AddEdgeTo(bLoad)
+ b.AddEdgeTo(bEnd)
+ bLoad.AddEdgeTo(bEnd)
+
+ s.startBlock(bLoad)
+ off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), tab)
+ s.vars[&typVar] = s.newValue2(ssa.OpLoad, byteptr, off, s.mem())
+ s.endBlock()
+
+ s.startBlock(bEnd)
+ typ := s.variable(&typVar, byteptr)
+ delete(s.vars, &typVar)
+ return typ
+}
+
+// dottype generates SSA for a type assertion node.
+// commaok indicates whether to panic or return a bool.
+// If commaok is false, resok will be nil.
+func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
+ iface := s.expr(n.Left)
+ typ := s.ifaceType(n.Left, iface) // actual concrete type
+ target := s.expr(typename(n.Type)) // target type
+ if !isdirectiface(n.Type) {
+ // walk rewrites ODOTTYPE/OAS2DOTTYPE into runtime calls except for this case.
+ Fatalf("dottype needs a direct iface type %s", n.Type)
+ }
+
+ if Debug_typeassert > 0 {
+ Warnl(int(n.Lineno), "type assertion inlined")
+ }
+
+ // TODO: If we have a nonempty interface and its itab field is nil,
+ // then this test is redundant and ifaceType should just branch directly to bFail.
+ cond := s.newValue2(ssa.OpEqPtr, Types[TBOOL], typ, target)
+ b := s.endBlock()
+ b.Kind = ssa.BlockIf
+ b.Control = cond
+ b.Likely = ssa.BranchLikely
+
+ byteptr := Ptrto(Types[TUINT8])
+
+ bOk := s.f.NewBlock(ssa.BlockPlain)
+ bFail := s.f.NewBlock(ssa.BlockPlain)
+ b.AddEdgeTo(bOk)
+ b.AddEdgeTo(bFail)
+
+ if !commaok {
+ // on failure, panic by calling panicdottype
+ s.startBlock(bFail)
+ taddr := s.newValue1A(ssa.OpAddr, byteptr, &ssa.ExternSymbol{byteptr, typenamesym(n.Left.Type)}, s.sb)
+ s.rtcall(panicdottype, false, nil, typ, target, taddr)
+
+ // on success, return idata field
+ s.startBlock(bOk)
+ return s.newValue1(ssa.OpIData, n.Type, iface), nil
+ }
+
+ // commaok is the more complicated case because we have
+ // a control flow merge point.
+ bEnd := s.f.NewBlock(ssa.BlockPlain)
+
+ // type assertion succeeded
+ s.startBlock(bOk)
+ s.vars[&idataVar] = s.newValue1(ssa.OpIData, n.Type, iface)
+ s.vars[&okVar] = s.constBool(true)
+ s.endBlock()
+ bOk.AddEdgeTo(bEnd)
+
+ // type assertion failed
+ s.startBlock(bFail)
+ s.vars[&idataVar] = s.entryNewValue0(ssa.OpConstNil, byteptr)
+ s.vars[&okVar] = s.constBool(false)
+ s.endBlock()
+ bFail.AddEdgeTo(bEnd)
+
+ // merge point
+ s.startBlock(bEnd)
+ res = s.variable(&idataVar, byteptr)
+ resok = s.variable(&okVar, Types[TBOOL])
+ delete(s.vars, &idataVar)
+ delete(s.vars, &okVar)
+ return res, resok
+}
+
+// checkgoto checks that a goto from from to to does not
+// jump into a block or jump over variable declarations.
+// It is a copy of checkgoto in the pre-SSA backend,
+// modified only for line number handling.
+// TODO: document how this works and why it is designed the way it is.
+func (s *state) checkgoto(from *Node, to *Node) {
+ if from.Sym == to.Sym {
+ return
+ }
+
+ nf := 0
+ for fs := from.Sym; fs != nil; fs = fs.Link {
+ nf++
+ }
+ nt := 0
+ for fs := to.Sym; fs != nil; fs = fs.Link {
+ nt++
+ }
+ fs := from.Sym
+ for ; nf > nt; nf-- {
+ fs = fs.Link
+ }
+ if fs != to.Sym {
+ // decide what to complain about.
+ // prefer to complain about 'into block' over declarations,
+ // so scan backward to find most recent block or else dcl.
+ var block *Sym
+
+ var dcl *Sym
+ ts := to.Sym
+ for ; nt > nf; nt-- {
+ if ts.Pkg == nil {
+ block = ts
+ } else {
+ dcl = ts
+ }
+ ts = ts.Link
+ }
+
+ for ts != fs {
+ if ts.Pkg == nil {
+ block = ts
+ } else {
+ dcl = ts
+ }
+ ts = ts.Link
+ fs = fs.Link
+ }
+
+ lno := int(from.Left.Lineno)
+ if block != nil {
+ yyerrorl(lno, "goto %v jumps into block starting at %v", from.Left.Sym, Ctxt.Line(int(block.Lastlineno)))
+ } else {
+ yyerrorl(lno, "goto %v jumps over declaration of %v at %v", from.Left.Sym, dcl, Ctxt.Line(int(dcl.Lastlineno)))
+ }
+ }
+}
+
+// variable returns the value of a variable at the current location.
+func (s *state) variable(name *Node, t ssa.Type) *ssa.Value {
+ v := s.vars[name]
+ if v == nil {
+ v = s.newValue0A(ssa.OpFwdRef, t, name)
+ s.fwdRefs = append(s.fwdRefs, v)
+ s.vars[name] = v
+ s.addNamedValue(name, v)
+ }
+ return v
+}
+
+func (s *state) mem() *ssa.Value {
+ return s.variable(&memVar, ssa.TypeMem)
+}
+
+func (s *state) linkForwardReferences() {
+ // Build SSA graph. Each variable on its first use in a basic block
+ // leaves a FwdRef in that block representing the incoming value
+ // of that variable. This function links that ref up with possible definitions,
+ // inserting Phi values as needed. This is essentially the algorithm
+ // described by Braun, Buchwald, Hack, Leißa, Mallon, and Zwinkau:
+ // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf
+ // Differences:
+ // - We use FwdRef nodes to postpone phi building until the CFG is
+ // completely built. That way we can avoid the notion of "sealed"
+ // blocks.
+ // - Phi optimization is a separate pass (in ../ssa/phielim.go).
+ for len(s.fwdRefs) > 0 {
+ v := s.fwdRefs[len(s.fwdRefs)-1]
+ s.fwdRefs = s.fwdRefs[:len(s.fwdRefs)-1]
+ s.resolveFwdRef(v)
+ }
+}
+
+// resolveFwdRef modifies v to be the variable's value at the start of its block.
+// v must be a FwdRef op.
+func (s *state) resolveFwdRef(v *ssa.Value) {
+ b := v.Block
+ name := v.Aux.(*Node)
+ v.Aux = nil
+ if b == s.f.Entry {
+ // Live variable at start of function.
+ if s.canSSA(name) {
+ v.Op = ssa.OpArg
+ v.Aux = name
+ return
+ }
+ // Not SSAable. Load it.
+ addr := s.decladdrs[name]
+ if addr == nil {
+ // TODO: closure args reach here.
+ s.Unimplementedf("unhandled closure arg %s at entry to function %s", name, b.Func.Name)
+ }
+ if _, ok := addr.Aux.(*ssa.ArgSymbol); !ok {
+ s.Fatalf("variable live at start of function %s is not an argument %s", b.Func.Name, name)
+ }
+ v.Op = ssa.OpLoad
+ v.AddArgs(addr, s.startmem)
+ return
+ }
+ if len(b.Preds) == 0 {
+ // This block is dead; we have no predecessors and we're not the entry block.
+ // It doesn't matter what we use here as long as it is well-formed.
+ v.Op = ssa.OpUnknown
+ return
+ }
+ // Find variable value on each predecessor.
+ var argstore [4]*ssa.Value
+ args := argstore[:0]
+ for _, p := range b.Preds {
+ args = append(args, s.lookupVarOutgoing(p, v.Type, name, v.Line))
+ }
+
+ // Decide if we need a phi or not. We need a phi if there
+ // are two different args (which are both not v).
+ var w *ssa.Value
+ for _, a := range args {
+ if a == v {
+ continue // self-reference
+ }
+ if a == w {
+ continue // already have this witness
+ }
+ if w != nil {
+ // two witnesses, need a phi value
+ v.Op = ssa.OpPhi
+ v.AddArgs(args...)
+ return
+ }
+ w = a // save witness
+ }
+ if w == nil {
+ s.Fatalf("no witness for reachable phi %s", v)
+ }
+ // One witness. Make v a copy of w.
+ v.Op = ssa.OpCopy
+ v.AddArg(w)
+}
+
+// lookupVarOutgoing finds the variable's value at the end of block b.
+func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name *Node, line int32) *ssa.Value {
+ m := s.defvars[b.ID]
+ if v, ok := m[name]; ok {
+ return v
+ }
+ // The variable is not defined by b and we haven't
+ // looked it up yet. Generate a FwdRef for the variable and return that.
+ v := b.NewValue0A(line, ssa.OpFwdRef, t, name)
+ s.fwdRefs = append(s.fwdRefs, v)
+ m[name] = v
+ s.addNamedValue(name, v)
+ return v
+}
+
+func (s *state) addNamedValue(n *Node, v *ssa.Value) {
+ if n.Class == Pxxx {
+ // Don't track our dummy nodes (&memVar etc.).
+ return
+ }
+ if strings.HasPrefix(n.Sym.Name, "autotmp_") {
+ // Don't track autotmp_ variables.
+ return
+ }
+ if n.Class == PAUTO && (v.Type.IsString() || v.Type.IsSlice() || v.Type.IsInterface()) {
+ // TODO: can't handle auto compound objects with pointers yet.
+ // The live variable analysis barfs because we don't put VARDEF
+ // pseudos in the right place when we spill to these nodes.
+ return
+ }
+ if n.Class == PAUTO && n.Xoffset != 0 {
+ s.Fatalf("AUTO var with offset %s %d", n, n.Xoffset)
+ }
+ loc := ssa.LocalSlot{N: n, Type: n.Type, Off: 0}
+ values, ok := s.f.NamedValues[loc]
+ if !ok {
+ s.f.Names = append(s.f.Names, loc)
+ }
+ s.f.NamedValues[loc] = append(values, v)
+}
+
+// an unresolved branch
+type branch struct {
+ p *obj.Prog // branch instruction
+ b *ssa.Block // target
+}
+
+type genState struct {
+ // branches remembers all the branch instructions we've seen
+ // and where they would like to go.
+ branches []branch
+
+ // bstart remembers where each block starts (indexed by block ID)
+ bstart []*obj.Prog
+
+ // deferBranches remembers all the defer branches we've seen.
+ deferBranches []*obj.Prog
+
+ // deferTarget remembers the (last) deferreturn call site.
+ deferTarget *obj.Prog
+}
+
+// genssa appends entries to ptxt for each instruction in f.
+// gcargs and gclocals are filled in with pointer maps for the frame.
+func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) {
+ var s genState
+
+ e := f.Config.Frontend().(*ssaExport)
+ // We're about to emit a bunch of Progs.
+ // Since the only way to get here is to explicitly request it,
+ // just fail on unimplemented instead of trying to unwind our mess.
+ e.mustImplement = true
+
+ // Remember where each block starts.
+ s.bstart = make([]*obj.Prog, f.NumBlocks())
+
+ var valueProgs map[*obj.Prog]*ssa.Value
+ var blockProgs map[*obj.Prog]*ssa.Block
+ const logProgs = true
+ if logProgs {
+ valueProgs = make(map[*obj.Prog]*ssa.Value, f.NumValues())
+ blockProgs = make(map[*obj.Prog]*ssa.Block, f.NumBlocks())
+ f.Logf("genssa %s\n", f.Name)
+ blockProgs[Pc] = f.Blocks[0]
+ }
+
+ // Emit basic blocks
+ for i, b := range f.Blocks {
+ s.bstart[b.ID] = Pc
+ // Emit values in block
+ s.markMoves(b)
+ for _, v := range b.Values {
+ x := Pc
+ s.genValue(v)
+ if logProgs {
+ for ; x != Pc; x = x.Link {
+ valueProgs[x] = v
+ }
+ }
+ }
+ // Emit control flow instructions for block
+ var next *ssa.Block
+ if i < len(f.Blocks)-1 && (Debug['N'] == 0 || b.Kind == ssa.BlockCall) {
+ // If -N, leave next==nil so every block with successors
+ // ends in a JMP (except call blocks - plive doesn't like
+ // select{send,recv} followed by a JMP call). Helps keep
+ // line numbers for otherwise empty blocks.
+ next = f.Blocks[i+1]
+ }
+ x := Pc
+ s.genBlock(b, next)
+ if logProgs {
+ for ; x != Pc; x = x.Link {
+ blockProgs[x] = b
+ }
+ }
+ }
+
+ // Resolve branches
+ for _, br := range s.branches {
+ br.p.To.Val = s.bstart[br.b.ID]
+ }
+ if s.deferBranches != nil && s.deferTarget == nil {
+ // This can happen when the function has a defer but
+ // no return (because it has an infinite loop).
+ s.deferReturn()
+ Prog(obj.ARET)
+ }
+ for _, p := range s.deferBranches {
+ p.To.Val = s.deferTarget
+ }
+
+ if logProgs {
+ for p := ptxt; p != nil; p = p.Link {
+ var s string
+ if v, ok := valueProgs[p]; ok {
+ s = v.String()
+ } else if b, ok := blockProgs[p]; ok {
+ s = b.String()
+ } else {
+ s = " " // most value and branch strings are 2-3 characters long
+ }
+ f.Logf("%s\t%s\n", s, p)
+ }
+ if f.Config.HTML != nil {
+ saved := ptxt.Ctxt.LineHist.PrintFilenameOnly
+ ptxt.Ctxt.LineHist.PrintFilenameOnly = true
+ var buf bytes.Buffer
+ buf.WriteString("<code>")
+ buf.WriteString("<dl class=\"ssa-gen\">")
+ for p := ptxt; p != nil; p = p.Link {
+ buf.WriteString("<dt class=\"ssa-prog-src\">")
+ if v, ok := valueProgs[p]; ok {
+ buf.WriteString(v.HTML())
+ } else if b, ok := blockProgs[p]; ok {
+ buf.WriteString(b.HTML())
+ }
+ buf.WriteString("</dt>")
+ buf.WriteString("<dd class=\"ssa-prog\">")
+ buf.WriteString(html.EscapeString(p.String()))
+ buf.WriteString("</dd>")
+ buf.WriteString("</li>")
+ }
+ buf.WriteString("</dl>")
+ buf.WriteString("</code>")
+ f.Config.HTML.WriteColumn("genssa", buf.String())
+ ptxt.Ctxt.LineHist.PrintFilenameOnly = saved
+ }
+ }
+
+ // Emit static data
+ if f.StaticData != nil {
+ for _, n := range f.StaticData.([]*Node) {
+ if !gen_as_init(n, false) {
+ Fatalf("non-static data marked as static: %v\n\n", n, f)
+ }
+ }
+ }
+
+ // Allocate stack frame
+ allocauto(ptxt)
+
+ // Generate gc bitmaps.
+ liveness(Curfn, ptxt, gcargs, gclocals)
+ gcsymdup(gcargs)
+ gcsymdup(gclocals)
+
+ // Add frame prologue. Zero ambiguously live variables.
+ Thearch.Defframe(ptxt)
+ if Debug['f'] != 0 {
+ frame(0)
+ }
+
+ // Remove leftover instrumentation from the instruction stream.
+ removevardef(ptxt)
+
+ f.Config.HTML.Close()
+}
+
+// opregreg emits instructions for
+// dest := dest(To) op src(From)
+// and also returns the created obj.Prog so it
+// may be further adjusted (offset, scale, etc).
+func opregreg(op int, dest, src int16) *obj.Prog {
+ p := Prog(op)
+ p.From.Type = obj.TYPE_REG
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = dest
+ p.From.Reg = src
+ return p
+}
+
+func (s *genState) genValue(v *ssa.Value) {
+ lineno = v.Line
+ switch v.Op {
+ case ssa.OpAMD64ADDQ, ssa.OpAMD64ADDL, ssa.OpAMD64ADDW:
+ r := regnum(v)
+ r1 := regnum(v.Args[0])
+ r2 := regnum(v.Args[1])
+ switch {
+ case r == r1:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = r2
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case r == r2:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = r1
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ default:
+ var asm int
+ switch v.Op {
+ case ssa.OpAMD64ADDQ:
+ asm = x86.ALEAQ
+ case ssa.OpAMD64ADDL:
+ asm = x86.ALEAL
+ case ssa.OpAMD64ADDW:
+ asm = x86.ALEAL
+ }
+ p := Prog(asm)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = r1
+ p.From.Scale = 1
+ p.From.Index = r2
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ // 2-address opcode arithmetic, symmetric
+ case ssa.OpAMD64ADDB, ssa.OpAMD64ADDSS, ssa.OpAMD64ADDSD,
+ ssa.OpAMD64ANDQ, ssa.OpAMD64ANDL, ssa.OpAMD64ANDW, ssa.OpAMD64ANDB,
+ ssa.OpAMD64ORQ, ssa.OpAMD64ORL, ssa.OpAMD64ORW, ssa.OpAMD64ORB,
+ ssa.OpAMD64XORQ, ssa.OpAMD64XORL, ssa.OpAMD64XORW, ssa.OpAMD64XORB,
+ ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW, ssa.OpAMD64MULB,
+ ssa.OpAMD64MULSS, ssa.OpAMD64MULSD, ssa.OpAMD64PXOR:
+ r := regnum(v)
+ x := regnum(v.Args[0])
+ y := regnum(v.Args[1])
+ if x != r && y != r {
+ opregreg(moveByType(v.Type), r, x)
+ x = r
+ }
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ if x == r {
+ p.From.Reg = y
+ } else {
+ p.From.Reg = x
+ }
+ // 2-address opcode arithmetic, not symmetric
+ case ssa.OpAMD64SUBQ, ssa.OpAMD64SUBL, ssa.OpAMD64SUBW, ssa.OpAMD64SUBB:
+ r := regnum(v)
+ x := regnum(v.Args[0])
+ y := regnum(v.Args[1])
+ var neg bool
+ if y == r {
+ // compute -(y-x) instead
+ x, y = y, x
+ neg = true
+ }
+ if x != r {
+ opregreg(moveByType(v.Type), r, x)
+ }
+ opregreg(v.Op.Asm(), r, y)
+
+ if neg {
+ if v.Op == ssa.OpAMD64SUBQ {
+ p := Prog(x86.ANEGQ)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ } else { // Avoids partial registers write
+ p := Prog(x86.ANEGL)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ }
+ case ssa.OpAMD64SUBSS, ssa.OpAMD64SUBSD, ssa.OpAMD64DIVSS, ssa.OpAMD64DIVSD:
+ r := regnum(v)
+ x := regnum(v.Args[0])
+ y := regnum(v.Args[1])
+ if y == r && x != r {
+ // r/y := x op r/y, need to preserve x and rewrite to
+ // r/y := r/y op x15
+ x15 := int16(x86.REG_X15)
+ // register move y to x15
+ // register move x to y
+ // rename y with x15
+ opregreg(moveByType(v.Type), x15, y)
+ opregreg(moveByType(v.Type), r, x)
+ y = x15
+ } else if x != r {
+ opregreg(moveByType(v.Type), r, x)
+ }
+ opregreg(v.Op.Asm(), r, y)
+
+ case ssa.OpAMD64DIVQ, ssa.OpAMD64DIVL, ssa.OpAMD64DIVW,
+ ssa.OpAMD64DIVQU, ssa.OpAMD64DIVLU, ssa.OpAMD64DIVWU,
+ ssa.OpAMD64MODQ, ssa.OpAMD64MODL, ssa.OpAMD64MODW,
+ ssa.OpAMD64MODQU, ssa.OpAMD64MODLU, ssa.OpAMD64MODWU:
+
+ // Arg[0] is already in AX as it's the only register we allow
+ // and AX is the only output
+ x := regnum(v.Args[1])
+
+ // CPU faults upon signed overflow, which occurs when most
+ // negative int is divided by -1.
+ var j *obj.Prog
+ if v.Op == ssa.OpAMD64DIVQ || v.Op == ssa.OpAMD64DIVL ||
+ v.Op == ssa.OpAMD64DIVW || v.Op == ssa.OpAMD64MODQ ||
+ v.Op == ssa.OpAMD64MODL || v.Op == ssa.OpAMD64MODW {
+
+ var c *obj.Prog
+ switch v.Op {
+ case ssa.OpAMD64DIVQ, ssa.OpAMD64MODQ:
+ c = Prog(x86.ACMPQ)
+ j = Prog(x86.AJEQ)
+ // go ahead and sign extend to save doing it later
+ Prog(x86.ACQO)
+
+ case ssa.OpAMD64DIVL, ssa.OpAMD64MODL:
+ c = Prog(x86.ACMPL)
+ j = Prog(x86.AJEQ)
+ Prog(x86.ACDQ)
+
+ case ssa.OpAMD64DIVW, ssa.OpAMD64MODW:
+ c = Prog(x86.ACMPW)
+ j = Prog(x86.AJEQ)
+ Prog(x86.ACWD)
+ }
+ c.From.Type = obj.TYPE_REG
+ c.From.Reg = x
+ c.To.Type = obj.TYPE_CONST
+ c.To.Offset = -1
+
+ j.To.Type = obj.TYPE_BRANCH
+
+ }
+
+ // for unsigned ints, we sign extend by setting DX = 0
+ // signed ints were sign extended above
+ if v.Op == ssa.OpAMD64DIVQU || v.Op == ssa.OpAMD64MODQU ||
+ v.Op == ssa.OpAMD64DIVLU || v.Op == ssa.OpAMD64MODLU ||
+ v.Op == ssa.OpAMD64DIVWU || v.Op == ssa.OpAMD64MODWU {
+ c := Prog(x86.AXORQ)
+ c.From.Type = obj.TYPE_REG
+ c.From.Reg = x86.REG_DX
+ c.To.Type = obj.TYPE_REG
+ c.To.Reg = x86.REG_DX
+ }
+
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+
+ // signed division, rest of the check for -1 case
+ if j != nil {
+ j2 := Prog(obj.AJMP)
+ j2.To.Type = obj.TYPE_BRANCH
+
+ var n *obj.Prog
+ if v.Op == ssa.OpAMD64DIVQ || v.Op == ssa.OpAMD64DIVL ||
+ v.Op == ssa.OpAMD64DIVW {
+ // n * -1 = -n
+ n = Prog(x86.ANEGQ)
+ n.To.Type = obj.TYPE_REG
+ n.To.Reg = x86.REG_AX
+ } else {
+ // n % -1 == 0
+ n = Prog(x86.AXORQ)
+ n.From.Type = obj.TYPE_REG
+ n.From.Reg = x86.REG_DX
+ n.To.Type = obj.TYPE_REG
+ n.To.Reg = x86.REG_DX
+ }
+
+ j.To.Val = n
+ j2.To.Val = Pc
+ }
+
+ case ssa.OpAMD64HMULQ, ssa.OpAMD64HMULL, ssa.OpAMD64HMULW, ssa.OpAMD64HMULB,
+ ssa.OpAMD64HMULQU, ssa.OpAMD64HMULLU, ssa.OpAMD64HMULWU, ssa.OpAMD64HMULBU:
+ // the frontend rewrites constant division by 8/16/32 bit integers into
+ // HMUL by a constant
+ // SSA rewrites generate the 64 bit versions
+
+ // Arg[0] is already in AX as it's the only register we allow
+ // and DX is the only output we care about (the high bits)
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[1])
+
+ // IMULB puts the high portion in AH instead of DL,
+ // so move it to DL for consistency
+ if v.Type.Size() == 1 {
+ m := Prog(x86.AMOVB)
+ m.From.Type = obj.TYPE_REG
+ m.From.Reg = x86.REG_AH
+ m.To.Type = obj.TYPE_REG
+ m.To.Reg = x86.REG_DX
+ }
+
+ case ssa.OpAMD64AVGQU:
+ // compute (x+y)/2 unsigned.
+ // Do a 64-bit add, the overflow goes into the carry.
+ // Shift right once and pull the carry back into the 63rd bit.
+ r := regnum(v)
+ x := regnum(v.Args[0])
+ y := regnum(v.Args[1])
+ if x != r && y != r {
+ opregreg(moveByType(v.Type), r, x)
+ x = r
+ }
+ p := Prog(x86.AADDQ)
+ p.From.Type = obj.TYPE_REG
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ if x == r {
+ p.From.Reg = y
+ } else {
+ p.From.Reg = x
+ }
+ p = Prog(x86.ARCRQ)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 1
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+
+ case ssa.OpAMD64SHLQ, ssa.OpAMD64SHLL, ssa.OpAMD64SHLW, ssa.OpAMD64SHLB,
+ ssa.OpAMD64SHRQ, ssa.OpAMD64SHRL, ssa.OpAMD64SHRW, ssa.OpAMD64SHRB,
+ ssa.OpAMD64SARQ, ssa.OpAMD64SARL, ssa.OpAMD64SARW, ssa.OpAMD64SARB:
+ x := regnum(v.Args[0])
+ r := regnum(v)
+ if x != r {
+ if r == x86.REG_CX {
+ v.Fatalf("can't implement %s, target and shift both in CX", v.LongString())
+ }
+ p := Prog(moveByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[1]) // should be CX
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case ssa.OpAMD64ADDQconst, ssa.OpAMD64ADDLconst, ssa.OpAMD64ADDWconst:
+ r := regnum(v)
+ a := regnum(v.Args[0])
+ if r == a {
+ if v.AuxInt2Int64() == 1 {
+ var asm int
+ switch v.Op {
+ // Software optimization manual recommends add $1,reg.
+ // But inc/dec is 1 byte smaller. ICC always uses inc
+ // Clang/GCC choose depending on flags, but prefer add.
+ // Experiments show that inc/dec is both a little faster
+ // and make a binary a little smaller.
+ case ssa.OpAMD64ADDQconst:
+ asm = x86.AINCQ
+ case ssa.OpAMD64ADDLconst:
+ asm = x86.AINCL
+ case ssa.OpAMD64ADDWconst:
+ asm = x86.AINCL
+ }
+ p := Prog(asm)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ return
+ } else if v.AuxInt2Int64() == -1 {
+ var asm int
+ switch v.Op {
+ case ssa.OpAMD64ADDQconst:
+ asm = x86.ADECQ
+ case ssa.OpAMD64ADDLconst:
+ asm = x86.ADECL
+ case ssa.OpAMD64ADDWconst:
+ asm = x86.ADECL
+ }
+ p := Prog(asm)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ return
+ } else {
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ return
+ }
+ }
+ var asm int
+ switch v.Op {
+ case ssa.OpAMD64ADDQconst:
+ asm = x86.ALEAQ
+ case ssa.OpAMD64ADDLconst:
+ asm = x86.ALEAL
+ case ssa.OpAMD64ADDWconst:
+ asm = x86.ALEAL
+ }
+ p := Prog(asm)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = a
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst, ssa.OpAMD64MULBconst:
+ r := regnum(v)
+ x := regnum(v.Args[0])
+ if r != x {
+ p := Prog(moveByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ // TODO: Teach doasm to compile the three-address multiply imul $c, r1, r2
+ // instead of using the MOVQ above.
+ //p.From3 = new(obj.Addr)
+ //p.From3.Type = obj.TYPE_REG
+ //p.From3.Reg = regnum(v.Args[0])
+ case ssa.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst, ssa.OpAMD64SUBWconst:
+ x := regnum(v.Args[0])
+ r := regnum(v)
+ // We have 3-op add (lea), so transforming a = b - const into
+ // a = b + (- const), saves us 1 instruction. We can't fit
+ // - (-1 << 31) into 4 bytes offset in lea.
+ // We handle 2-address just fine below.
+ if v.AuxInt2Int64() == -1<<31 || x == r {
+ if x != r {
+ // This code compensates for the fact that the register allocator
+ // doesn't understand 2-address instructions yet. TODO: fix that.
+ p := Prog(moveByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ } else if x == r && v.AuxInt2Int64() == -1 {
+ var asm int
+ // x = x - (-1) is the same as x++
+ // See OpAMD64ADDQconst comments about inc vs add $1,reg
+ switch v.Op {
+ case ssa.OpAMD64SUBQconst:
+ asm = x86.AINCQ
+ case ssa.OpAMD64SUBLconst:
+ asm = x86.AINCL
+ case ssa.OpAMD64SUBWconst:
+ asm = x86.AINCL
+ }
+ p := Prog(asm)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ } else if x == r && v.AuxInt2Int64() == 1 {
+ var asm int
+ switch v.Op {
+ case ssa.OpAMD64SUBQconst:
+ asm = x86.ADECQ
+ case ssa.OpAMD64SUBLconst:
+ asm = x86.ADECL
+ case ssa.OpAMD64SUBWconst:
+ asm = x86.ADECL
+ }
+ p := Prog(asm)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ } else {
+ var asm int
+ switch v.Op {
+ case ssa.OpAMD64SUBQconst:
+ asm = x86.ALEAQ
+ case ssa.OpAMD64SUBLconst:
+ asm = x86.ALEAL
+ case ssa.OpAMD64SUBWconst:
+ asm = x86.ALEAL
+ }
+ p := Prog(asm)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = x
+ p.From.Offset = -v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+
+ case ssa.OpAMD64ADDBconst,
+ ssa.OpAMD64ANDQconst, ssa.OpAMD64ANDLconst, ssa.OpAMD64ANDWconst, ssa.OpAMD64ANDBconst,
+ ssa.OpAMD64ORQconst, ssa.OpAMD64ORLconst, ssa.OpAMD64ORWconst, ssa.OpAMD64ORBconst,
+ ssa.OpAMD64XORQconst, ssa.OpAMD64XORLconst, ssa.OpAMD64XORWconst, ssa.OpAMD64XORBconst,
+ ssa.OpAMD64SUBBconst, ssa.OpAMD64SHLQconst, ssa.OpAMD64SHLLconst, ssa.OpAMD64SHLWconst,
+ ssa.OpAMD64SHLBconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SHRLconst, ssa.OpAMD64SHRWconst,
+ ssa.OpAMD64SHRBconst, ssa.OpAMD64SARQconst, ssa.OpAMD64SARLconst, ssa.OpAMD64SARWconst,
+ ssa.OpAMD64SARBconst, ssa.OpAMD64ROLQconst, ssa.OpAMD64ROLLconst, ssa.OpAMD64ROLWconst,
+ ssa.OpAMD64ROLBconst:
+ // This code compensates for the fact that the register allocator
+ // doesn't understand 2-address instructions yet. TODO: fix that.
+ x := regnum(v.Args[0])
+ r := regnum(v)
+ if x != r {
+ p := Prog(moveByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case ssa.OpAMD64SBBQcarrymask, ssa.OpAMD64SBBLcarrymask:
+ r := regnum(v)
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = r
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case ssa.OpAMD64LEAQ1, ssa.OpAMD64LEAQ2, ssa.OpAMD64LEAQ4, ssa.OpAMD64LEAQ8:
+ p := Prog(x86.ALEAQ)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ switch v.Op {
+ case ssa.OpAMD64LEAQ1:
+ p.From.Scale = 1
+ case ssa.OpAMD64LEAQ2:
+ p.From.Scale = 2
+ case ssa.OpAMD64LEAQ4:
+ p.From.Scale = 4
+ case ssa.OpAMD64LEAQ8:
+ p.From.Scale = 8
+ }
+ p.From.Index = regnum(v.Args[1])
+ addAux(&p.From, v)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64LEAQ:
+ p := Prog(x86.ALEAQ)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB,
+ ssa.OpAMD64TESTQ, ssa.OpAMD64TESTL, ssa.OpAMD64TESTW, ssa.OpAMD64TESTB:
+ opregreg(v.Op.Asm(), regnum(v.Args[1]), regnum(v.Args[0]))
+ case ssa.OpAMD64UCOMISS, ssa.OpAMD64UCOMISD:
+ // Go assembler has swapped operands for UCOMISx relative to CMP,
+ // must account for that right here.
+ opregreg(v.Op.Asm(), regnum(v.Args[0]), regnum(v.Args[1]))
+ case ssa.OpAMD64CMPQconst, ssa.OpAMD64CMPLconst, ssa.OpAMD64CMPWconst, ssa.OpAMD64CMPBconst:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[0])
+ p.To.Type = obj.TYPE_CONST
+ p.To.Offset = v.AuxInt2Int64()
+ case ssa.OpAMD64TESTQconst, ssa.OpAMD64TESTLconst, ssa.OpAMD64TESTWconst, ssa.OpAMD64TESTBconst:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v.Args[0])
+ case ssa.OpAMD64MOVBconst, ssa.OpAMD64MOVWconst, ssa.OpAMD64MOVLconst, ssa.OpAMD64MOVQconst:
+ x := regnum(v)
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = v.AuxInt2Int64()
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = x
+ // If flags are live at this instruction, suppress the
+ // MOV $0,AX -> XOR AX,AX optimization.
+ if v.Aux != nil {
+ p.Mark |= x86.PRESERVEFLAGS
+ }
+ case ssa.OpAMD64MOVSSconst, ssa.OpAMD64MOVSDconst:
+ x := regnum(v)
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_FCONST
+ p.From.Val = math.Float64frombits(uint64(v.AuxInt))
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = x
+ case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVSSload, ssa.OpAMD64MOVSDload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload, ssa.OpAMD64MOVWQSXload, ssa.OpAMD64MOVWQZXload, ssa.OpAMD64MOVLQSXload, ssa.OpAMD64MOVLQZXload, ssa.OpAMD64MOVOload:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64MOVQloadidx8, ssa.OpAMD64MOVSDloadidx8:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.From.Scale = 8
+ p.From.Index = regnum(v.Args[1])
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64MOVLloadidx4, ssa.OpAMD64MOVSSloadidx4:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.From.Scale = 4
+ p.From.Index = regnum(v.Args[1])
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64MOVWloadidx2:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.From.Scale = 2
+ p.From.Index = regnum(v.Args[1])
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64MOVBloadidx1:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = regnum(v.Args[0])
+ addAux(&p.From, v)
+ p.From.Scale = 1
+ p.From.Index = regnum(v.Args[1])
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore, ssa.OpAMD64MOVOstore:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[1])
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ addAux(&p.To, v)
+ case ssa.OpAMD64MOVQstoreidx8, ssa.OpAMD64MOVSDstoreidx8:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[2])
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ p.To.Scale = 8
+ p.To.Index = regnum(v.Args[1])
+ addAux(&p.To, v)
+ case ssa.OpAMD64MOVSSstoreidx4, ssa.OpAMD64MOVLstoreidx4:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[2])
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ p.To.Scale = 4
+ p.To.Index = regnum(v.Args[1])
+ addAux(&p.To, v)
+ case ssa.OpAMD64MOVWstoreidx2:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[2])
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ p.To.Scale = 2
+ p.To.Index = regnum(v.Args[1])
+ addAux(&p.To, v)
+ case ssa.OpAMD64MOVBstoreidx1:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[2])
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ p.To.Scale = 1
+ p.To.Index = regnum(v.Args[1])
+ addAux(&p.To, v)
+ case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ sc := v.AuxValAndOff()
+ i := sc.Val()
+ switch v.Op {
+ case ssa.OpAMD64MOVBstoreconst:
+ i = int64(int8(i))
+ case ssa.OpAMD64MOVWstoreconst:
+ i = int64(int16(i))
+ case ssa.OpAMD64MOVLstoreconst:
+ i = int64(int32(i))
+ case ssa.OpAMD64MOVQstoreconst:
+ }
+ p.From.Offset = i
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ addAux2(&p.To, v, sc.Off())
+ case ssa.OpAMD64MOVQstoreconstidx8, ssa.OpAMD64MOVLstoreconstidx4, ssa.OpAMD64MOVWstoreconstidx2, ssa.OpAMD64MOVBstoreconstidx1:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_CONST
+ sc := v.AuxValAndOff()
+ switch v.Op {
+ case ssa.OpAMD64MOVBstoreconstidx1:
+ p.From.Offset = int64(int8(sc.Val()))
+ p.To.Scale = 1
+ case ssa.OpAMD64MOVWstoreconstidx2:
+ p.From.Offset = int64(int16(sc.Val()))
+ p.To.Scale = 2
+ case ssa.OpAMD64MOVLstoreconstidx4:
+ p.From.Offset = int64(int32(sc.Val()))
+ p.To.Scale = 4
+ case ssa.OpAMD64MOVQstoreconstidx8:
+ p.From.Offset = sc.Val()
+ p.To.Scale = 8
+ }
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ p.To.Index = regnum(v.Args[1])
+ addAux2(&p.To, v, sc.Off())
+ case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX,
+ ssa.OpAMD64CVTSL2SS, ssa.OpAMD64CVTSL2SD, ssa.OpAMD64CVTSQ2SS, ssa.OpAMD64CVTSQ2SD,
+ ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ,
+ ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS:
+ opregreg(v.Op.Asm(), regnum(v), regnum(v.Args[0]))
+ case ssa.OpAMD64DUFFZERO:
+ p := Prog(obj.ADUFFZERO)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = Linksym(Pkglookup("duffzero", Runtimepkg))
+ p.To.Offset = v.AuxInt
+ case ssa.OpAMD64MOVOconst:
+ if v.AuxInt != 0 {
+ v.Unimplementedf("MOVOconst can only do constant=0")
+ }
+ r := regnum(v)
+ opregreg(x86.AXORPS, r, r)
+ case ssa.OpAMD64DUFFCOPY:
+ p := Prog(obj.ADUFFCOPY)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = Linksym(Pkglookup("duffcopy", Runtimepkg))
+ p.To.Offset = v.AuxInt
+
+ case ssa.OpCopy, ssa.OpAMD64MOVQconvert: // TODO: use MOVQreg for reg->reg copies instead of OpCopy?
+ if v.Type.IsMemory() {
+ return
+ }
+ x := regnum(v.Args[0])
+ y := regnum(v)
+ if x != y {
+ opregreg(moveByType(v.Type), y, x)
+ }
+ case ssa.OpLoadReg:
+ if v.Type.IsFlags() {
+ v.Unimplementedf("load flags not implemented: %v", v.LongString())
+ return
+ }
+ p := Prog(loadByType(v.Type))
+ n, off := autoVar(v.Args[0])
+ p.From.Type = obj.TYPE_MEM
+ p.From.Node = n
+ p.From.Sym = Linksym(n.Sym)
+ p.From.Offset = off
+ if n.Class == PPARAM || n.Class == PPARAMOUT {
+ p.From.Name = obj.NAME_PARAM
+ p.From.Offset += n.Xoffset
+ } else {
+ p.From.Name = obj.NAME_AUTO
+ }
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+
+ case ssa.OpStoreReg:
+ if v.Type.IsFlags() {
+ v.Unimplementedf("store flags not implemented: %v", v.LongString())
+ return
+ }
+ p := Prog(storeByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[0])
+ n, off := autoVar(v)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Node = n
+ p.To.Sym = Linksym(n.Sym)
+ p.To.Offset = off
+ if n.Class == PPARAM || n.Class == PPARAMOUT {
+ p.To.Name = obj.NAME_PARAM
+ p.To.Offset += n.Xoffset
+ } else {
+ p.To.Name = obj.NAME_AUTO
+ }
+ case ssa.OpPhi:
+ // just check to make sure regalloc and stackalloc did it right
+ if v.Type.IsMemory() {
+ return
+ }
+ f := v.Block.Func
+ loc := f.RegAlloc[v.ID]
+ for _, a := range v.Args {
+ if aloc := f.RegAlloc[a.ID]; aloc != loc { // TODO: .Equal() instead?
+ v.Fatalf("phi arg at different location than phi: %v @ %v, but arg %v @ %v\n%s\n", v, loc, a, aloc, v.Block.Func)
+ }
+ }
+ case ssa.OpInitMem:
+ // memory arg needs no code
+ case ssa.OpArg:
+ // input args need no code
+ case ssa.OpAMD64LoweredGetClosurePtr:
+ // Output is hardwired to DX only,
+ // and DX contains the closure pointer on
+ // closure entry, and this "instruction"
+ // is scheduled to the very beginning
+ // of the entry block.
+ case ssa.OpAMD64LoweredGetG:
+ r := regnum(v)
+ // See the comments in cmd/internal/obj/x86/obj6.go
+ // near CanUse1InsnTLS for a detailed explanation of these instructions.
+ if x86.CanUse1InsnTLS(Ctxt) {
+ // MOVQ (TLS), r
+ p := Prog(x86.AMOVQ)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Reg = x86.REG_TLS
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ } else {
+ // MOVQ TLS, r
+ // MOVQ (r)(TLS*1), r
+ p := Prog(x86.AMOVQ)
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x86.REG_TLS
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ q := Prog(x86.AMOVQ)
+ q.From.Type = obj.TYPE_MEM
+ q.From.Reg = r
+ q.From.Index = x86.REG_TLS
+ q.From.Scale = 1
+ q.To.Type = obj.TYPE_REG
+ q.To.Reg = r
+ }
+ case ssa.OpAMD64CALLstatic:
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(v.Aux.(*Sym))
+ if Maxarg < v.AuxInt {
+ Maxarg = v.AuxInt
+ }
+ case ssa.OpAMD64CALLclosure:
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v.Args[0])
+ if Maxarg < v.AuxInt {
+ Maxarg = v.AuxInt
+ }
+ case ssa.OpAMD64CALLdefer:
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(Deferproc.Sym)
+ if Maxarg < v.AuxInt {
+ Maxarg = v.AuxInt
+ }
+ // defer returns in rax:
+ // 0 if we should continue executing
+ // 1 if we should jump to deferreturn call
+ p = Prog(x86.ATESTL)
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x86.REG_AX
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = x86.REG_AX
+ p = Prog(x86.AJNE)
+ p.To.Type = obj.TYPE_BRANCH
+ s.deferBranches = append(s.deferBranches, p)
+ case ssa.OpAMD64CALLgo:
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(Newproc.Sym)
+ if Maxarg < v.AuxInt {
+ Maxarg = v.AuxInt
+ }
+ case ssa.OpAMD64CALLinter:
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v.Args[0])
+ if Maxarg < v.AuxInt {
+ Maxarg = v.AuxInt
+ }
+ case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB,
+ ssa.OpAMD64NOTQ, ssa.OpAMD64NOTL, ssa.OpAMD64NOTW, ssa.OpAMD64NOTB:
+ x := regnum(v.Args[0])
+ r := regnum(v)
+ if x != r {
+ p := Prog(moveByType(v.Type))
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ }
+ p := Prog(v.Op.Asm())
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = r
+ case ssa.OpAMD64SQRTSD:
+ p := Prog(v.Op.Asm())
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = regnum(v.Args[0])
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ case ssa.OpSP, ssa.OpSB:
+ // nothing to do
+ case ssa.OpAMD64SETEQ, ssa.OpAMD64SETNE,
+ ssa.OpAMD64SETL, ssa.OpAMD64SETLE,
+ ssa.OpAMD64SETG, ssa.OpAMD64SETGE,
+ ssa.OpAMD64SETGF, ssa.OpAMD64SETGEF,
+ ssa.OpAMD64SETB, ssa.OpAMD64SETBE,
+ ssa.OpAMD64SETORD, ssa.OpAMD64SETNAN,
+ ssa.OpAMD64SETA, ssa.OpAMD64SETAE:
+ p := Prog(v.Op.Asm())
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+
+ case ssa.OpAMD64SETNEF:
+ p := Prog(v.Op.Asm())
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ q := Prog(x86.ASETPS)
+ q.To.Type = obj.TYPE_REG
+ q.To.Reg = x86.REG_AX
+ // ORL avoids partial register write and is smaller than ORQ, used by old compiler
+ opregreg(x86.AORL, regnum(v), x86.REG_AX)
+
+ case ssa.OpAMD64SETEQF:
+ p := Prog(v.Op.Asm())
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = regnum(v)
+ q := Prog(x86.ASETPC)
+ q.To.Type = obj.TYPE_REG
+ q.To.Reg = x86.REG_AX
+ // ANDL avoids partial register write and is smaller than ANDQ, used by old compiler
+ opregreg(x86.AANDL, regnum(v), x86.REG_AX)
+
+ case ssa.OpAMD64InvertFlags:
+ v.Fatalf("InvertFlags should never make it to codegen %v", v)
+ case ssa.OpAMD64FlagEQ, ssa.OpAMD64FlagLT_ULT, ssa.OpAMD64FlagLT_UGT, ssa.OpAMD64FlagGT_ULT, ssa.OpAMD64FlagGT_UGT:
+ v.Fatalf("Flag* ops should never make it to codegen %v", v)
+ case ssa.OpAMD64REPSTOSQ:
+ Prog(x86.AREP)
+ Prog(x86.ASTOSQ)
+ case ssa.OpAMD64REPMOVSQ:
+ Prog(x86.AREP)
+ Prog(x86.AMOVSQ)
+ case ssa.OpVarDef:
+ Gvardef(v.Aux.(*Node))
+ case ssa.OpVarKill:
+ gvarkill(v.Aux.(*Node))
+ case ssa.OpVarLive:
+ gvarlive(v.Aux.(*Node))
+ case ssa.OpAMD64LoweredNilCheck:
+ // Optimization - if the subsequent block has a load or store
+ // at the same address, we don't need to issue this instruction.
+ mem := v.Args[1]
+ for _, w := range v.Block.Succs[0].Values {
+ if w.Op == ssa.OpPhi {
+ if w.Type.IsMemory() {
+ mem = w
+ }
+ continue
+ }
+ if len(w.Args) == 0 || !w.Args[len(w.Args)-1].Type.IsMemory() {
+ // w doesn't use a store - can't be a memory op.
+ continue
+ }
+ if w.Args[len(w.Args)-1] != mem {
+ v.Fatalf("wrong store after nilcheck v=%s w=%s", v, w)
+ }
+ switch w.Op {
+ case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload,
+ ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore,
+ ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload, ssa.OpAMD64MOVWQSXload,
+ ssa.OpAMD64MOVWQZXload, ssa.OpAMD64MOVLQSXload, ssa.OpAMD64MOVLQZXload,
+ ssa.OpAMD64MOVSSload, ssa.OpAMD64MOVSDload, ssa.OpAMD64MOVOload,
+ ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVOstore:
+ if w.Args[0] == v.Args[0] && w.Aux == nil && w.AuxInt >= 0 && w.AuxInt < minZeroPage {
+ if Debug_checknil != 0 && int(v.Line) > 1 {
+ Warnl(int(v.Line), "removed nil check")
+ }
+ return
+ }
+ case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst:
+ off := ssa.ValAndOff(v.AuxInt).Off()
+ if w.Args[0] == v.Args[0] && w.Aux == nil && off >= 0 && off < minZeroPage {
+ if Debug_checknil != 0 && int(v.Line) > 1 {
+ Warnl(int(v.Line), "removed nil check")
+ }
+ return
+ }
+ }
+ if w.Type.IsMemory() {
+ if w.Op == ssa.OpVarDef || w.Op == ssa.OpVarKill || w.Op == ssa.OpVarLive {
+ // these ops are OK
+ mem = w
+ continue
+ }
+ // We can't delay the nil check past the next store.
+ break
+ }
+ }
+ // Issue a load which will fault if the input is nil.
+ // TODO: We currently use the 2-byte instruction TESTB AX, (reg).
+ // Should we use the 3-byte TESTB $0, (reg) instead? It is larger
+ // but it doesn't have false dependency on AX.
+ // Or maybe allocate an output register and use MOVL (reg),reg2 ?
+ // That trades clobbering flags for clobbering a register.
+ p := Prog(x86.ATESTB)
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = x86.REG_AX
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum(v.Args[0])
+ addAux(&p.To, v)
+ if Debug_checknil != 0 && v.Line > 1 { // v.Line==1 in generated wrappers
+ Warnl(int(v.Line), "generated nil check")
+ }
+ default:
+ v.Unimplementedf("genValue not implemented: %s", v.LongString())
+ }
+}
+
+// markMoves marks any MOVXconst ops that need to avoid clobbering flags.
+func (s *genState) markMoves(b *ssa.Block) {
+ flive := b.FlagsLiveAtEnd
+ if b.Control != nil && b.Control.Type.IsFlags() {
+ flive = true
+ }
+ for i := len(b.Values) - 1; i >= 0; i-- {
+ v := b.Values[i]
+ if flive && (v.Op == ssa.OpAMD64MOVBconst || v.Op == ssa.OpAMD64MOVWconst || v.Op == ssa.OpAMD64MOVLconst || v.Op == ssa.OpAMD64MOVQconst) {
+ // The "mark" is any non-nil Aux value.
+ v.Aux = v
+ }
+ if v.Type.IsFlags() {
+ flive = false
+ }
+ for _, a := range v.Args {
+ if a.Type.IsFlags() {
+ flive = true
+ }
+ }
+ }
+}
+
+// movZero generates a register indirect move with a 0 immediate and keeps track of bytes left and next offset
+func movZero(as int, width int64, nbytes int64, offset int64, regnum int16) (nleft int64, noff int64) {
+ p := Prog(as)
+ // TODO: use zero register on archs that support it.
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 0
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = regnum
+ p.To.Offset = offset
+ offset += width
+ nleft = nbytes - width
+ return nleft, offset
+}
+
+var blockJump = [...]struct {
+ asm, invasm int
+}{
+ ssa.BlockAMD64EQ: {x86.AJEQ, x86.AJNE},
+ ssa.BlockAMD64NE: {x86.AJNE, x86.AJEQ},
+ ssa.BlockAMD64LT: {x86.AJLT, x86.AJGE},
+ ssa.BlockAMD64GE: {x86.AJGE, x86.AJLT},
+ ssa.BlockAMD64LE: {x86.AJLE, x86.AJGT},
+ ssa.BlockAMD64GT: {x86.AJGT, x86.AJLE},
+ ssa.BlockAMD64ULT: {x86.AJCS, x86.AJCC},
+ ssa.BlockAMD64UGE: {x86.AJCC, x86.AJCS},
+ ssa.BlockAMD64UGT: {x86.AJHI, x86.AJLS},
+ ssa.BlockAMD64ULE: {x86.AJLS, x86.AJHI},
+ ssa.BlockAMD64ORD: {x86.AJPC, x86.AJPS},
+ ssa.BlockAMD64NAN: {x86.AJPS, x86.AJPC},
+}
+
+type floatingEQNEJump struct {
+ jump, index int
+}
+
+var eqfJumps = [2][2]floatingEQNEJump{
+ {{x86.AJNE, 1}, {x86.AJPS, 1}}, // next == b.Succs[0]
+ {{x86.AJNE, 1}, {x86.AJPC, 0}}, // next == b.Succs[1]
+}
+var nefJumps = [2][2]floatingEQNEJump{
+ {{x86.AJNE, 0}, {x86.AJPC, 1}}, // next == b.Succs[0]
+ {{x86.AJNE, 0}, {x86.AJPS, 0}}, // next == b.Succs[1]
+}
+
+func oneFPJump(b *ssa.Block, jumps *floatingEQNEJump, likely ssa.BranchPrediction, branches []branch) []branch {
+ p := Prog(jumps.jump)
+ p.To.Type = obj.TYPE_BRANCH
+ to := jumps.index
+ branches = append(branches, branch{p, b.Succs[to]})
+ if to == 1 {
+ likely = -likely
+ }
+ // liblink reorders the instruction stream as it sees fit.
+ // Pass along what we know so liblink can make use of it.
+ // TODO: Once we've fully switched to SSA,
+ // make liblink leave our output alone.
+ switch likely {
+ case ssa.BranchUnlikely:
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 0
+ case ssa.BranchLikely:
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 1
+ }
+ return branches
+}
+
+func genFPJump(s *genState, b, next *ssa.Block, jumps *[2][2]floatingEQNEJump) {
+ likely := b.Likely
+ switch next {
+ case b.Succs[0]:
+ s.branches = oneFPJump(b, &jumps[0][0], likely, s.branches)
+ s.branches = oneFPJump(b, &jumps[0][1], likely, s.branches)
+ case b.Succs[1]:
+ s.branches = oneFPJump(b, &jumps[1][0], likely, s.branches)
+ s.branches = oneFPJump(b, &jumps[1][1], likely, s.branches)
+ default:
+ s.branches = oneFPJump(b, &jumps[1][0], likely, s.branches)
+ s.branches = oneFPJump(b, &jumps[1][1], likely, s.branches)
+ q := Prog(obj.AJMP)
+ q.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{q, b.Succs[1]})
+ }
+}
+
+func (s *genState) genBlock(b, next *ssa.Block) {
+ lineno = b.Line
+
+ switch b.Kind {
+ case ssa.BlockPlain, ssa.BlockCall, ssa.BlockCheck:
+ if b.Succs[0] != next {
+ p := Prog(obj.AJMP)
+ p.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{p, b.Succs[0]})
+ }
+ case ssa.BlockExit:
+ Prog(obj.AUNDEF) // tell plive.go that we never reach here
+ case ssa.BlockRet:
+ if hasdefer {
+ s.deferReturn()
+ }
+ Prog(obj.ARET)
+ case ssa.BlockRetJmp:
+ p := Prog(obj.AJMP)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(b.Aux.(*Sym))
+
+ case ssa.BlockAMD64EQF:
+ genFPJump(s, b, next, &eqfJumps)
+
+ case ssa.BlockAMD64NEF:
+ genFPJump(s, b, next, &nefJumps)
+
+ case ssa.BlockAMD64EQ, ssa.BlockAMD64NE,
+ ssa.BlockAMD64LT, ssa.BlockAMD64GE,
+ ssa.BlockAMD64LE, ssa.BlockAMD64GT,
+ ssa.BlockAMD64ULT, ssa.BlockAMD64UGT,
+ ssa.BlockAMD64ULE, ssa.BlockAMD64UGE:
+ jmp := blockJump[b.Kind]
+ likely := b.Likely
+ var p *obj.Prog
+ switch next {
+ case b.Succs[0]:
+ p = Prog(jmp.invasm)
+ likely *= -1
+ p.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{p, b.Succs[1]})
+ case b.Succs[1]:
+ p = Prog(jmp.asm)
+ p.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{p, b.Succs[0]})
+ default:
+ p = Prog(jmp.asm)
+ p.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{p, b.Succs[0]})
+ q := Prog(obj.AJMP)
+ q.To.Type = obj.TYPE_BRANCH
+ s.branches = append(s.branches, branch{q, b.Succs[1]})
+ }
+
+ // liblink reorders the instruction stream as it sees fit.
+ // Pass along what we know so liblink can make use of it.
+ // TODO: Once we've fully switched to SSA,
+ // make liblink leave our output alone.
+ switch likely {
+ case ssa.BranchUnlikely:
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 0
+ case ssa.BranchLikely:
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 1
+ }
+
+ default:
+ b.Unimplementedf("branch not implemented: %s. Control: %s", b.LongString(), b.Control.LongString())
+ }
+}
+
+func (s *genState) deferReturn() {
+ // Deferred calls will appear to be returning to
+ // the CALL deferreturn(SB) that we are about to emit.
+ // However, the stack trace code will show the line
+ // of the instruction byte before the return PC.
+ // To avoid that being an unrelated instruction,
+ // insert an actual hardware NOP that will have the right line number.
+ // This is different from obj.ANOP, which is a virtual no-op
+ // that doesn't make it into the instruction stream.
+ s.deferTarget = Pc
+ Thearch.Ginsnop()
+ p := Prog(obj.ACALL)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(Deferreturn.Sym)
+}
+
+// addAux adds the offset in the aux fields (AuxInt and Aux) of v to a.
+func addAux(a *obj.Addr, v *ssa.Value) {
+ addAux2(a, v, v.AuxInt)
+}
+func addAux2(a *obj.Addr, v *ssa.Value, offset int64) {
+ if a.Type != obj.TYPE_MEM {
+ v.Fatalf("bad addAux addr %s", a)
+ }
+ // add integer offset
+ a.Offset += offset
+
+ // If no additional symbol offset, we're done.
+ if v.Aux == nil {
+ return
+ }
+ // Add symbol's offset from its base register.
+ switch sym := v.Aux.(type) {
+ case *ssa.ExternSymbol:
+ a.Name = obj.NAME_EXTERN
+ a.Sym = Linksym(sym.Sym.(*Sym))
+ case *ssa.ArgSymbol:
+ n := sym.Node.(*Node)
+ a.Name = obj.NAME_PARAM
+ a.Node = n
+ a.Sym = Linksym(n.Orig.Sym)
+ a.Offset += n.Xoffset // TODO: why do I have to add this here? I don't for auto variables.
+ case *ssa.AutoSymbol:
+ n := sym.Node.(*Node)
+ a.Name = obj.NAME_AUTO
+ a.Node = n
+ a.Sym = Linksym(n.Sym)
+ default:
+ v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
+ }
+}
+
+// extendIndex extends v to a full int width.
+func (s *state) extendIndex(v *ssa.Value) *ssa.Value {
+ size := v.Type.Size()
+ if size == s.config.IntSize {
+ return v
+ }
+ if size > s.config.IntSize {
+ // TODO: truncate 64-bit indexes on 32-bit pointer archs. We'd need to test
+ // the high word and branch to out-of-bounds failure if it is not 0.
+ s.Unimplementedf("64->32 index truncation not implemented")
+ return v
+ }
+
+ // Extend value to the required size
+ var op ssa.Op
+ if v.Type.IsSigned() {
+ switch 10*size + s.config.IntSize {
+ case 14:
+ op = ssa.OpSignExt8to32
+ case 18:
+ op = ssa.OpSignExt8to64
+ case 24:
+ op = ssa.OpSignExt16to32
+ case 28:
+ op = ssa.OpSignExt16to64
+ case 48:
+ op = ssa.OpSignExt32to64
+ default:
+ s.Fatalf("bad signed index extension %s", v.Type)
+ }
+ } else {
+ switch 10*size + s.config.IntSize {
+ case 14:
+ op = ssa.OpZeroExt8to32
+ case 18:
+ op = ssa.OpZeroExt8to64
+ case 24:
+ op = ssa.OpZeroExt16to32
+ case 28:
+ op = ssa.OpZeroExt16to64
+ case 48:
+ op = ssa.OpZeroExt32to64
+ default:
+ s.Fatalf("bad unsigned index extension %s", v.Type)
+ }
+ }
+ return s.newValue1(op, Types[TINT], v)
+}
+
+// ssaRegToReg maps ssa register numbers to obj register numbers.
+var ssaRegToReg = [...]int16{
+ x86.REG_AX,
+ x86.REG_CX,
+ x86.REG_DX,
+ x86.REG_BX,
+ x86.REG_SP,
+ x86.REG_BP,
+ x86.REG_SI,
+ x86.REG_DI,
+ x86.REG_R8,
+ x86.REG_R9,
+ x86.REG_R10,
+ x86.REG_R11,
+ x86.REG_R12,
+ x86.REG_R13,
+ x86.REG_R14,
+ x86.REG_R15,
+ x86.REG_X0,
+ x86.REG_X1,
+ x86.REG_X2,
+ x86.REG_X3,
+ x86.REG_X4,
+ x86.REG_X5,
+ x86.REG_X6,
+ x86.REG_X7,
+ x86.REG_X8,
+ x86.REG_X9,
+ x86.REG_X10,
+ x86.REG_X11,
+ x86.REG_X12,
+ x86.REG_X13,
+ x86.REG_X14,
+ x86.REG_X15,
+ 0, // SB isn't a real register. We fill an Addr.Reg field with 0 in this case.
+ // TODO: arch-dependent
+}
+
+// loadByType returns the load instruction of the given type.
+func loadByType(t ssa.Type) int {
+ // Avoid partial register write
+ if !t.IsFloat() && t.Size() <= 2 {
+ if t.Size() == 1 {
+ return x86.AMOVBLZX
+ } else {
+ return x86.AMOVWLZX
+ }
+ }
+ // Otherwise, there's no difference between load and store opcodes.
+ return storeByType(t)
+}
+
+// storeByType returns the store instruction of the given type.
+func storeByType(t ssa.Type) int {
+ width := t.Size()
+ if t.IsFloat() {
+ switch width {
+ case 4:
+ return x86.AMOVSS
+ case 8:
+ return x86.AMOVSD
+ }
+ } else {
+ switch width {
+ case 1:
+ return x86.AMOVB
+ case 2:
+ return x86.AMOVW
+ case 4:
+ return x86.AMOVL
+ case 8:
+ return x86.AMOVQ
+ }
+ }
+ panic("bad store type")
+}
+
+// moveByType returns the reg->reg move instruction of the given type.
+func moveByType(t ssa.Type) int {
+ if t.IsFloat() {
+ // Moving the whole sse2 register is faster
+ // than moving just the correct low portion of it.
+ // There is no xmm->xmm move with 1 byte opcode,
+ // so use movups, which has 2 byte opcode.
+ return x86.AMOVUPS
+ } else {
+ switch t.Size() {
+ case 1:
+ // Avoids partial register write
+ return x86.AMOVL
+ case 2:
+ return x86.AMOVL
+ case 4:
+ return x86.AMOVL
+ case 8:
+ return x86.AMOVQ
+ default:
+ panic("bad int register width")
+ }
+ }
+ panic("bad register type")
+}
+
+// regnum returns the register (in cmd/internal/obj numbering) to
+// which v has been allocated. Panics if v is not assigned to a
+// register.
+// TODO: Make this panic again once it stops happening routinely.
+func regnum(v *ssa.Value) int16 {
+ reg := v.Block.Func.RegAlloc[v.ID]
+ if reg == nil {
+ v.Unimplementedf("nil regnum for value: %s\n%s\n", v.LongString(), v.Block.Func)
+ return 0
+ }
+ return ssaRegToReg[reg.(*ssa.Register).Num]
+}
+
+// autoVar returns a *Node and int64 representing the auto variable and offset within it
+// where v should be spilled.
+func autoVar(v *ssa.Value) (*Node, int64) {
+ loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
+ if v.Type.Size() > loc.Type.Size() {
+ v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
+ }
+ return loc.N.(*Node), loc.Off
+}
+
+// fieldIdx finds the index of the field referred to by the ODOT node n.
+func fieldIdx(n *Node) int64 {
+ t := n.Left.Type
+ f := n.Right
+ if t.Etype != TSTRUCT {
+ panic("ODOT's LHS is not a struct")
+ }
+
+ var i int64
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Etype != TFIELD {
+ panic("non-TFIELD in TSTRUCT")
+ }
+ if t1.Sym != f.Sym {
+ i++
+ continue
+ }
+ if t1.Width != n.Xoffset {
+ panic("field offset doesn't match")
+ }
+ return i
+ }
+ panic(fmt.Sprintf("can't find field in expr %s\n", n))
+
+ // TODO: keep the result of this fucntion somewhere in the ODOT Node
+ // so we don't have to recompute it each time we need it.
+}
+
+// ssaExport exports a bunch of compiler services for the ssa backend.
+type ssaExport struct {
+ log bool
+ unimplemented bool
+ mustImplement bool
+}
+
+func (s *ssaExport) TypeBool() ssa.Type { return Types[TBOOL] }
+func (s *ssaExport) TypeInt8() ssa.Type { return Types[TINT8] }
+func (s *ssaExport) TypeInt16() ssa.Type { return Types[TINT16] }
+func (s *ssaExport) TypeInt32() ssa.Type { return Types[TINT32] }
+func (s *ssaExport) TypeInt64() ssa.Type { return Types[TINT64] }
+func (s *ssaExport) TypeUInt8() ssa.Type { return Types[TUINT8] }
+func (s *ssaExport) TypeUInt16() ssa.Type { return Types[TUINT16] }
+func (s *ssaExport) TypeUInt32() ssa.Type { return Types[TUINT32] }
+func (s *ssaExport) TypeUInt64() ssa.Type { return Types[TUINT64] }
+func (s *ssaExport) TypeFloat32() ssa.Type { return Types[TFLOAT32] }
+func (s *ssaExport) TypeFloat64() ssa.Type { return Types[TFLOAT64] }
+func (s *ssaExport) TypeInt() ssa.Type { return Types[TINT] }
+func (s *ssaExport) TypeUintptr() ssa.Type { return Types[TUINTPTR] }
+func (s *ssaExport) TypeString() ssa.Type { return Types[TSTRING] }
+func (s *ssaExport) TypeBytePtr() ssa.Type { return Ptrto(Types[TUINT8]) }
+
+// StringData returns a symbol (a *Sym wrapped in an interface) which
+// is the data component of a global string constant containing s.
+func (*ssaExport) StringData(s string) interface{} {
+ // TODO: is idealstring correct? It might not matter...
+ _, data := stringsym(s)
+ return &ssa.ExternSymbol{Typ: idealstring, Sym: data}
+}
+
+func (e *ssaExport) Auto(t ssa.Type) ssa.GCNode {
+ n := temp(t.(*Type)) // Note: adds new auto to Curfn.Func.Dcl list
+ e.mustImplement = true // This modifies the input to SSA, so we want to make sure we succeed from here!
+ return n
+}
+
+func (e *ssaExport) CanSSA(t ssa.Type) bool {
+ return canSSAType(t.(*Type))
+}
+
+func (e *ssaExport) Line(line int32) string {
+ return Ctxt.Line(int(line))
+}
+
+// Log logs a message from the compiler.
+func (e *ssaExport) Logf(msg string, args ...interface{}) {
+ // If e was marked as unimplemented, anything could happen. Ignore.
+ if e.log && !e.unimplemented {
+ fmt.Printf(msg, args...)
+ }
+}
+
+func (e *ssaExport) Log() bool {
+ return e.log
+}
+
+// Fatal reports a compiler error and exits.
+func (e *ssaExport) Fatalf(line int32, msg string, args ...interface{}) {
+ // If e was marked as unimplemented, anything could happen. Ignore.
+ if !e.unimplemented {
+ lineno = line
+ Fatalf(msg, args...)
+ }
+}
+
+// Unimplemented reports that the function cannot be compiled.
+// It will be removed once SSA work is complete.
+func (e *ssaExport) Unimplementedf(line int32, msg string, args ...interface{}) {
+ if e.mustImplement {
+ lineno = line
+ Fatalf(msg, args...)
+ }
+ const alwaysLog = false // enable to calculate top unimplemented features
+ if !e.unimplemented && (e.log || alwaysLog) {
+ // first implementation failure, print explanation
+ fmt.Printf("SSA unimplemented: "+msg+"\n", args...)
+ }
+ e.unimplemented = true
+}
+
+// Warnl reports a "warning", which is usually flag-triggered
+// logging output for the benefit of tests.
+func (e *ssaExport) Warnl(line int, fmt_ string, args ...interface{}) {
+ Warnl(line, fmt_, args...)
+}
+
+func (e *ssaExport) Debug_checknil() bool {
+ return Debug_checknil != 0
+}
+
+func (n *Node) Typ() ssa.Type {
+ return n.Type
+}
diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go
new file mode 100644
index 0000000..d0c44b5
--- /dev/null
+++ b/src/cmd/compile/internal/gc/ssa_test.go
@@ -0,0 +1,99 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gc
+
+import (
+ "bytes"
+ "internal/testenv"
+ "os/exec"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "testing"
+)
+
+// TODO: move all these tests elsewhere?
+// Perhaps teach test/run.go how to run them with a new action verb.
+func runTest(t *testing.T, filename string) {
+ doTest(t, filename, "run")
+}
+func buildTest(t *testing.T, filename string) {
+ doTest(t, filename, "build")
+}
+func doTest(t *testing.T, filename string, kind string) {
+ if runtime.GOARCH != "amd64" {
+ t.Skipf("skipping SSA tests on %s for now", runtime.GOARCH)
+ }
+ testenv.MustHaveGoBuild(t)
+ var stdout, stderr bytes.Buffer
+ cmd := exec.Command("go", kind, filepath.Join("testdata", filename))
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+ if err := cmd.Run(); err != nil {
+ t.Fatalf("Failed: %v:\nOut: %s\nStderr: %s\n", err, &stdout, &stderr)
+ }
+ if s := stdout.String(); s != "" {
+ t.Errorf("Stdout = %s\nWant empty", s)
+ }
+ if s := stderr.String(); strings.Contains(s, "SSA unimplemented") {
+ t.Errorf("Unimplemented message found in stderr:\n%s", s)
+ }
+}
+
+// TestShortCircuit tests OANDAND and OOROR expressions and short circuiting.
+func TestShortCircuit(t *testing.T) { runTest(t, "short_ssa.go") }
+
+// TestBreakContinue tests that continue and break statements do what they say.
+func TestBreakContinue(t *testing.T) { runTest(t, "break_ssa.go") }
+
+// TestTypeAssertion tests type assertions.
+func TestTypeAssertion(t *testing.T) { runTest(t, "assert_ssa.go") }
+
+// TestArithmetic tests that both backends have the same result for arithmetic expressions.
+func TestArithmetic(t *testing.T) { runTest(t, "arith_ssa.go") }
+
+// TestFP tests that both backends have the same result for floating point expressions.
+func TestFP(t *testing.T) { runTest(t, "fp_ssa.go") }
+
+// TestArithmeticBoundary tests boundary results for arithmetic operations.
+func TestArithmeticBoundary(t *testing.T) { runTest(t, "arithBoundary_ssa.go") }
+
+// TestArithmeticConst tests results for arithmetic operations against constants.
+func TestArithmeticConst(t *testing.T) { runTest(t, "arithConst_ssa.go") }
+
+func TestChan(t *testing.T) { runTest(t, "chan_ssa.go") }
+
+func TestCompound(t *testing.T) { runTest(t, "compound_ssa.go") }
+
+func TestCtl(t *testing.T) { runTest(t, "ctl_ssa.go") }
+
+func TestFp(t *testing.T) { runTest(t, "fp_ssa.go") }
+
+func TestLoadStore(t *testing.T) { runTest(t, "loadstore_ssa.go") }
+
+func TestMap(t *testing.T) { runTest(t, "map_ssa.go") }
+
+func TestRegalloc(t *testing.T) { runTest(t, "regalloc_ssa.go") }
+
+func TestString(t *testing.T) { runTest(t, "string_ssa.go") }
+
+func TestDeferNoReturn(t *testing.T) { buildTest(t, "deferNoReturn_ssa.go") }
+
+// TestClosure tests closure related behavior.
+func TestClosure(t *testing.T) { runTest(t, "closure_ssa.go") }
+
+func TestArray(t *testing.T) { runTest(t, "array_ssa.go") }
+
+func TestAppend(t *testing.T) { runTest(t, "append_ssa.go") }
+
+func TestZero(t *testing.T) { runTest(t, "zero_ssa.go") }
+
+func TestAddressed(t *testing.T) { runTest(t, "addressed_ssa.go") }
+
+func TestCopy(t *testing.T) { runTest(t, "copy_ssa.go") }
+
+func TestUnsafe(t *testing.T) { runTest(t, "unsafe_ssa.go") }
+
+func TestPhi(t *testing.T) { runTest(t, "phi_ssa.go") }
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 72944a7..6e1406e 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -149,7 +149,7 @@
// Func holds Node fields used only with function-like nodes.
type Func struct {
Shortname *Node
- Enter Nodes
+ Enter Nodes // for example, allocate and initialize memory for escaping parameters
Exit Nodes
Cvars Nodes // closure params
Dcl []*Node // autodcl for this func/closure
diff --git a/src/cmd/compile/internal/gc/testdata/addressed_ssa.go b/src/cmd/compile/internal/gc/testdata/addressed_ssa.go
new file mode 100644
index 0000000..f9f4593
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/addressed_ssa.go
@@ -0,0 +1,216 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "fmt"
+
+var output string
+
+func mypanic(s string) {
+ fmt.Printf(output)
+ panic(s)
+}
+
+func assertEqual(x, y int) {
+ if x != y {
+ mypanic("assertEqual failed")
+ }
+}
+
+func main() {
+ x := f1_ssa(2, 3)
+ output += fmt.Sprintln("*x is", *x)
+ output += fmt.Sprintln("Gratuitously use some stack")
+ output += fmt.Sprintln("*x is", *x)
+ assertEqual(*x, 9)
+
+ w := f3a_ssa(6)
+ output += fmt.Sprintln("*w is", *w)
+ output += fmt.Sprintln("Gratuitously use some stack")
+ output += fmt.Sprintln("*w is", *w)
+ assertEqual(*w, 6)
+
+ y := f3b_ssa(12)
+ output += fmt.Sprintln("*y.(*int) is", *y.(*int))
+ output += fmt.Sprintln("Gratuitously use some stack")
+ output += fmt.Sprintln("*y.(*int) is", *y.(*int))
+ assertEqual(*y.(*int), 12)
+
+ z := f3c_ssa(8)
+ output += fmt.Sprintln("*z.(*int) is", *z.(*int))
+ output += fmt.Sprintln("Gratuitously use some stack")
+ output += fmt.Sprintln("*z.(*int) is", *z.(*int))
+ assertEqual(*z.(*int), 8)
+
+ args()
+ test_autos()
+}
+
+func f1_ssa(x, y int) *int {
+ switch {
+ } //go:noinline
+ x = x*y + y
+ return &x
+}
+
+func f3a_ssa(x int) *int {
+ switch {
+ } //go:noinline
+ return &x
+}
+
+func f3b_ssa(x int) interface{} { // ./foo.go:15: internal error: f3b_ssa ~r1 (type interface {}) recorded as live on entry
+ switch {
+ } //go:noinline
+ return &x
+}
+
+func f3c_ssa(y int) interface{} {
+ switch {
+ } //go:noinline
+ x := y
+ return &x
+}
+
+type V struct {
+ p *V
+ w, x int64
+}
+
+func args() {
+ v := V{p: nil, w: 1, x: 1}
+ a := V{p: &v, w: 2, x: 2}
+ b := V{p: &v, w: 0, x: 0}
+ i := v.args_ssa(a, b)
+ output += fmt.Sprintln("i=", i)
+ assertEqual(int(i), 2)
+}
+
+func (v V) args_ssa(a, b V) int64 {
+ switch {
+ } //go:noinline
+ if v.w == 0 {
+ return v.x
+ }
+ if v.w == 1 {
+ return a.x
+ }
+ if v.w == 2 {
+ return b.x
+ }
+ b.p.p = &a // v.p in caller = &a
+
+ return -1
+}
+
+func test_autos() {
+ test(11)
+ test(12)
+ test(13)
+ test(21)
+ test(22)
+ test(23)
+ test(31)
+ test(32)
+}
+
+func test(which int64) {
+ output += fmt.Sprintln("test", which)
+ v1 := V{w: 30, x: 3, p: nil}
+ v2, v3 := v1.autos_ssa(which, 10, 1, 20, 2)
+ if which != v2.val() {
+ output += fmt.Sprintln("Expected which=", which, "got v2.val()=", v2.val())
+ mypanic("Failure of expected V value")
+ }
+ if v2.p.val() != v3.val() {
+ output += fmt.Sprintln("Expected v2.p.val()=", v2.p.val(), "got v3.val()=", v3.val())
+ mypanic("Failure of expected V.p value")
+ }
+ if which != v3.p.p.p.p.p.p.p.val() {
+ output += fmt.Sprintln("Expected which=", which, "got v3.p.p.p.p.p.p.p.val()=", v3.p.p.p.p.p.p.p.val())
+ mypanic("Failure of expected V.p value")
+ }
+}
+
+func (v V) val() int64 {
+ return v.w + v.x
+}
+
+// autos_ssa uses contents of v and parameters w1, w2, x1, x2
+// to initialize a bunch of locals, all of which have their
+// address taken to force heap allocation, and then based on
+// the value of which a pair of those locals are copied in
+// various ways to the two results y, and z, which are also
+// addressed. Which is expected to be one of 11-13, 21-23, 31, 32,
+// and y.val() should be equal to which and y.p.val() should
+// be equal to z.val(). Also, x(.p)**8 == x; that is, the
+// autos are all linked into a ring.
+func (v V) autos_ssa(which, w1, x1, w2, x2 int64) (y, z V) {
+ switch {
+ } //go:noinline
+ fill_ssa(v.w, v.x, &v, v.p) // gratuitous no-op to force addressing
+ var a, b, c, d, e, f, g, h V
+ fill_ssa(w1, x1, &a, &b)
+ fill_ssa(w1, x2, &b, &c)
+ fill_ssa(w1, v.x, &c, &d)
+ fill_ssa(w2, x1, &d, &e)
+ fill_ssa(w2, x2, &e, &f)
+ fill_ssa(w2, v.x, &f, &g)
+ fill_ssa(v.w, x1, &g, &h)
+ fill_ssa(v.w, x2, &h, &a)
+ switch which {
+ case 11:
+ y = a
+ z.getsI(&b)
+ case 12:
+ y.gets(&b)
+ z = c
+ case 13:
+ y.gets(&c)
+ z = d
+ case 21:
+ y.getsI(&d)
+ z.gets(&e)
+ case 22:
+ y = e
+ z = f
+ case 23:
+ y.gets(&f)
+ z.getsI(&g)
+ case 31:
+ y = g
+ z.gets(&h)
+ case 32:
+ y.getsI(&h)
+ z = a
+ default:
+
+ panic("")
+ }
+ return
+}
+
+// gets is an address-mentioning way of implementing
+// structure assignment.
+func (to *V) gets(from *V) {
+ switch {
+ } //go:noinline
+ *to = *from
+}
+
+// gets is an address-and-interface-mentioning way of
+// implementing structure assignment.
+func (to *V) getsI(from interface{}) {
+ switch {
+ } //go:noinline
+ *to = *from.(*V)
+}
+
+// fill_ssa initializes r with V{w:w, x:x, p:p}
+func fill_ssa(w, x int64, r, p *V) {
+ switch {
+ } //go:noinline
+ *r = V{w: w, x: x, p: p}
+}
diff --git a/src/cmd/compile/internal/gc/testdata/append_ssa.go b/src/cmd/compile/internal/gc/testdata/append_ssa.go
new file mode 100644
index 0000000..03cd219
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/append_ssa.go
@@ -0,0 +1,70 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// append_ssa.go tests append operations.
+package main
+
+import "fmt"
+
+var failed = false
+
+//go:noinline
+func appendOne_ssa(a []int, x int) []int {
+ return append(a, x)
+}
+
+//go:noinline
+func appendThree_ssa(a []int, x, y, z int) []int {
+ return append(a, x, y, z)
+}
+
+func eq(a, b []int) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i := range a {
+ if a[i] != b[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func expect(got, want []int) {
+ if eq(got, want) {
+ return
+ }
+ fmt.Printf("expected %v, got %v\n", want, got)
+ failed = true
+}
+
+func testAppend() {
+ var store [7]int
+ a := store[:0]
+
+ a = appendOne_ssa(a, 1)
+ expect(a, []int{1})
+ a = appendThree_ssa(a, 2, 3, 4)
+ expect(a, []int{1, 2, 3, 4})
+ a = appendThree_ssa(a, 5, 6, 7)
+ expect(a, []int{1, 2, 3, 4, 5, 6, 7})
+ if &a[0] != &store[0] {
+ fmt.Println("unnecessary grow")
+ failed = true
+ }
+ a = appendOne_ssa(a, 8)
+ expect(a, []int{1, 2, 3, 4, 5, 6, 7, 8})
+ if &a[0] == &store[0] {
+ fmt.Println("didn't grow")
+ failed = true
+ }
+}
+
+func main() {
+ testAppend()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go
new file mode 100644
index 0000000..929e4e1
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go
@@ -0,0 +1,735 @@
+package main
+
+import "fmt"
+
+type utd64 struct {
+ a, b uint64
+ add, sub, mul, div, mod uint64
+}
+type itd64 struct {
+ a, b int64
+ add, sub, mul, div, mod int64
+}
+type utd32 struct {
+ a, b uint32
+ add, sub, mul, div, mod uint32
+}
+type itd32 struct {
+ a, b int32
+ add, sub, mul, div, mod int32
+}
+type utd16 struct {
+ a, b uint16
+ add, sub, mul, div, mod uint16
+}
+type itd16 struct {
+ a, b int16
+ add, sub, mul, div, mod int16
+}
+type utd8 struct {
+ a, b uint8
+ add, sub, mul, div, mod uint8
+}
+type itd8 struct {
+ a, b int8
+ add, sub, mul, div, mod int8
+}
+
+//go:noinline
+func add_uint64_ssa(a, b uint64) uint64 {
+ return a + b
+}
+
+//go:noinline
+func sub_uint64_ssa(a, b uint64) uint64 {
+ return a - b
+}
+
+//go:noinline
+func div_uint64_ssa(a, b uint64) uint64 {
+ return a / b
+}
+
+//go:noinline
+func mod_uint64_ssa(a, b uint64) uint64 {
+ return a % b
+}
+
+//go:noinline
+func mul_uint64_ssa(a, b uint64) uint64 {
+ return a * b
+}
+
+//go:noinline
+func add_int64_ssa(a, b int64) int64 {
+ return a + b
+}
+
+//go:noinline
+func sub_int64_ssa(a, b int64) int64 {
+ return a - b
+}
+
+//go:noinline
+func div_int64_ssa(a, b int64) int64 {
+ return a / b
+}
+
+//go:noinline
+func mod_int64_ssa(a, b int64) int64 {
+ return a % b
+}
+
+//go:noinline
+func mul_int64_ssa(a, b int64) int64 {
+ return a * b
+}
+
+//go:noinline
+func add_uint32_ssa(a, b uint32) uint32 {
+ return a + b
+}
+
+//go:noinline
+func sub_uint32_ssa(a, b uint32) uint32 {
+ return a - b
+}
+
+//go:noinline
+func div_uint32_ssa(a, b uint32) uint32 {
+ return a / b
+}
+
+//go:noinline
+func mod_uint32_ssa(a, b uint32) uint32 {
+ return a % b
+}
+
+//go:noinline
+func mul_uint32_ssa(a, b uint32) uint32 {
+ return a * b
+}
+
+//go:noinline
+func add_int32_ssa(a, b int32) int32 {
+ return a + b
+}
+
+//go:noinline
+func sub_int32_ssa(a, b int32) int32 {
+ return a - b
+}
+
+//go:noinline
+func div_int32_ssa(a, b int32) int32 {
+ return a / b
+}
+
+//go:noinline
+func mod_int32_ssa(a, b int32) int32 {
+ return a % b
+}
+
+//go:noinline
+func mul_int32_ssa(a, b int32) int32 {
+ return a * b
+}
+
+//go:noinline
+func add_uint16_ssa(a, b uint16) uint16 {
+ return a + b
+}
+
+//go:noinline
+func sub_uint16_ssa(a, b uint16) uint16 {
+ return a - b
+}
+
+//go:noinline
+func div_uint16_ssa(a, b uint16) uint16 {
+ return a / b
+}
+
+//go:noinline
+func mod_uint16_ssa(a, b uint16) uint16 {
+ return a % b
+}
+
+//go:noinline
+func mul_uint16_ssa(a, b uint16) uint16 {
+ return a * b
+}
+
+//go:noinline
+func add_int16_ssa(a, b int16) int16 {
+ return a + b
+}
+
+//go:noinline
+func sub_int16_ssa(a, b int16) int16 {
+ return a - b
+}
+
+//go:noinline
+func div_int16_ssa(a, b int16) int16 {
+ return a / b
+}
+
+//go:noinline
+func mod_int16_ssa(a, b int16) int16 {
+ return a % b
+}
+
+//go:noinline
+func mul_int16_ssa(a, b int16) int16 {
+ return a * b
+}
+
+//go:noinline
+func add_uint8_ssa(a, b uint8) uint8 {
+ return a + b
+}
+
+//go:noinline
+func sub_uint8_ssa(a, b uint8) uint8 {
+ return a - b
+}
+
+//go:noinline
+func div_uint8_ssa(a, b uint8) uint8 {
+ return a / b
+}
+
+//go:noinline
+func mod_uint8_ssa(a, b uint8) uint8 {
+ return a % b
+}
+
+//go:noinline
+func mul_uint8_ssa(a, b uint8) uint8 {
+ return a * b
+}
+
+//go:noinline
+func add_int8_ssa(a, b int8) int8 {
+ return a + b
+}
+
+//go:noinline
+func sub_int8_ssa(a, b int8) int8 {
+ return a - b
+}
+
+//go:noinline
+func div_int8_ssa(a, b int8) int8 {
+ return a / b
+}
+
+//go:noinline
+func mod_int8_ssa(a, b int8) int8 {
+ return a % b
+}
+
+//go:noinline
+func mul_int8_ssa(a, b int8) int8 {
+ return a * b
+}
+
+var uint64_data []utd64 = []utd64{utd64{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ utd64{a: 0, b: 1, add: 1, sub: 18446744073709551615, mul: 0, div: 0, mod: 0},
+ utd64{a: 0, b: 4294967296, add: 4294967296, sub: 18446744069414584320, mul: 0, div: 0, mod: 0},
+ utd64{a: 0, b: 18446744073709551615, add: 18446744073709551615, sub: 1, mul: 0, div: 0, mod: 0},
+ utd64{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ utd64{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ utd64{a: 1, b: 4294967296, add: 4294967297, sub: 18446744069414584321, mul: 4294967296, div: 0, mod: 1},
+ utd64{a: 1, b: 18446744073709551615, add: 0, sub: 2, mul: 18446744073709551615, div: 0, mod: 1},
+ utd64{a: 4294967296, b: 0, add: 4294967296, sub: 4294967296, mul: 0},
+ utd64{a: 4294967296, b: 1, add: 4294967297, sub: 4294967295, mul: 4294967296, div: 4294967296, mod: 0},
+ utd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1, mod: 0},
+ utd64{a: 4294967296, b: 18446744073709551615, add: 4294967295, sub: 4294967297, mul: 18446744069414584320, div: 0, mod: 4294967296},
+ utd64{a: 18446744073709551615, b: 0, add: 18446744073709551615, sub: 18446744073709551615, mul: 0},
+ utd64{a: 18446744073709551615, b: 1, add: 0, sub: 18446744073709551614, mul: 18446744073709551615, div: 18446744073709551615, mod: 0},
+ utd64{a: 18446744073709551615, b: 4294967296, add: 4294967295, sub: 18446744069414584319, mul: 18446744069414584320, div: 4294967295, mod: 4294967295},
+ utd64{a: 18446744073709551615, b: 18446744073709551615, add: 18446744073709551614, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var int64_data []itd64 = []itd64{itd64{a: -9223372036854775808, b: -9223372036854775808, add: 0, sub: 0, mul: 0, div: 1, mod: 0},
+ itd64{a: -9223372036854775808, b: -9223372036854775807, add: 1, sub: -1, mul: -9223372036854775808, div: 1, mod: -1},
+ itd64{a: -9223372036854775808, b: -4294967296, add: 9223372032559808512, sub: -9223372032559808512, mul: 0, div: 2147483648, mod: 0},
+ itd64{a: -9223372036854775808, b: -1, add: 9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: -9223372036854775808, mod: 0},
+ itd64{a: -9223372036854775808, b: 0, add: -9223372036854775808, sub: -9223372036854775808, mul: 0},
+ itd64{a: -9223372036854775808, b: 1, add: -9223372036854775807, sub: 9223372036854775807, mul: -9223372036854775808, div: -9223372036854775808, mod: 0},
+ itd64{a: -9223372036854775808, b: 4294967296, add: -9223372032559808512, sub: 9223372032559808512, mul: 0, div: -2147483648, mod: 0},
+ itd64{a: -9223372036854775808, b: 9223372036854775806, add: -2, sub: 2, mul: 0, div: -1, mod: -2},
+ itd64{a: -9223372036854775808, b: 9223372036854775807, add: -1, sub: 1, mul: -9223372036854775808, div: -1, mod: -1},
+ itd64{a: -9223372036854775807, b: -9223372036854775808, add: 1, sub: 1, mul: -9223372036854775808, div: 0, mod: -9223372036854775807},
+ itd64{a: -9223372036854775807, b: -9223372036854775807, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd64{a: -9223372036854775807, b: -4294967296, add: 9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 2147483647, mod: -4294967295},
+ itd64{a: -9223372036854775807, b: -1, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 9223372036854775807, mod: 0},
+ itd64{a: -9223372036854775807, b: 0, add: -9223372036854775807, sub: -9223372036854775807, mul: 0},
+ itd64{a: -9223372036854775807, b: 1, add: -9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: -9223372036854775807, mod: 0},
+ itd64{a: -9223372036854775807, b: 4294967296, add: -9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: -2147483647, mod: -4294967295},
+ itd64{a: -9223372036854775807, b: 9223372036854775806, add: -1, sub: 3, mul: 9223372036854775806, div: -1, mod: -1},
+ itd64{a: -9223372036854775807, b: 9223372036854775807, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd64{a: -4294967296, b: -9223372036854775808, add: 9223372032559808512, sub: 9223372032559808512, mul: 0, div: 0, mod: -4294967296},
+ itd64{a: -4294967296, b: -9223372036854775807, add: 9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 0, mod: -4294967296},
+ itd64{a: -4294967296, b: -4294967296, add: -8589934592, sub: 0, mul: 0, div: 1, mod: 0},
+ itd64{a: -4294967296, b: -1, add: -4294967297, sub: -4294967295, mul: 4294967296, div: 4294967296, mod: 0},
+ itd64{a: -4294967296, b: 0, add: -4294967296, sub: -4294967296, mul: 0},
+ itd64{a: -4294967296, b: 1, add: -4294967295, sub: -4294967297, mul: -4294967296, div: -4294967296, mod: 0},
+ itd64{a: -4294967296, b: 4294967296, add: 0, sub: -8589934592, mul: 0, div: -1, mod: 0},
+ itd64{a: -4294967296, b: 9223372036854775806, add: 9223372032559808510, sub: 9223372032559808514, mul: 8589934592, div: 0, mod: -4294967296},
+ itd64{a: -4294967296, b: 9223372036854775807, add: 9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: 0, mod: -4294967296},
+ itd64{a: -1, b: -9223372036854775808, add: 9223372036854775807, sub: 9223372036854775807, mul: -9223372036854775808, div: 0, mod: -1},
+ itd64{a: -1, b: -9223372036854775807, add: -9223372036854775808, sub: 9223372036854775806, mul: 9223372036854775807, div: 0, mod: -1},
+ itd64{a: -1, b: -4294967296, add: -4294967297, sub: 4294967295, mul: 4294967296, div: 0, mod: -1},
+ itd64{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd64{a: -1, b: 0, add: -1, sub: -1, mul: 0},
+ itd64{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd64{a: -1, b: 4294967296, add: 4294967295, sub: -4294967297, mul: -4294967296, div: 0, mod: -1},
+ itd64{a: -1, b: 9223372036854775806, add: 9223372036854775805, sub: -9223372036854775807, mul: -9223372036854775806, div: 0, mod: -1},
+ itd64{a: -1, b: 9223372036854775807, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0, mod: -1},
+ itd64{a: 0, b: -9223372036854775808, add: -9223372036854775808, sub: -9223372036854775808, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: -9223372036854775807, add: -9223372036854775807, sub: 9223372036854775807, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: -4294967296, add: -4294967296, sub: 4294967296, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ itd64{a: 0, b: 1, add: 1, sub: -1, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: 4294967296, add: 4294967296, sub: -4294967296, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: 9223372036854775806, add: 9223372036854775806, sub: -9223372036854775806, mul: 0, div: 0, mod: 0},
+ itd64{a: 0, b: 9223372036854775807, add: 9223372036854775807, sub: -9223372036854775807, mul: 0, div: 0, mod: 0},
+ itd64{a: 1, b: -9223372036854775808, add: -9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: 0, mod: 1},
+ itd64{a: 1, b: -9223372036854775807, add: -9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0, mod: 1},
+ itd64{a: 1, b: -4294967296, add: -4294967295, sub: 4294967297, mul: -4294967296, div: 0, mod: 1},
+ itd64{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd64{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ itd64{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd64{a: 1, b: 4294967296, add: 4294967297, sub: -4294967295, mul: 4294967296, div: 0, mod: 1},
+ itd64{a: 1, b: 9223372036854775806, add: 9223372036854775807, sub: -9223372036854775805, mul: 9223372036854775806, div: 0, mod: 1},
+ itd64{a: 1, b: 9223372036854775807, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 0, mod: 1},
+ itd64{a: 4294967296, b: -9223372036854775808, add: -9223372032559808512, sub: -9223372032559808512, mul: 0, div: 0, mod: 4294967296},
+ itd64{a: 4294967296, b: -9223372036854775807, add: -9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: 0, mod: 4294967296},
+ itd64{a: 4294967296, b: -4294967296, add: 0, sub: 8589934592, mul: 0, div: -1, mod: 0},
+ itd64{a: 4294967296, b: -1, add: 4294967295, sub: 4294967297, mul: -4294967296, div: -4294967296, mod: 0},
+ itd64{a: 4294967296, b: 0, add: 4294967296, sub: 4294967296, mul: 0},
+ itd64{a: 4294967296, b: 1, add: 4294967297, sub: 4294967295, mul: 4294967296, div: 4294967296, mod: 0},
+ itd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1, mod: 0},
+ itd64{a: 4294967296, b: 9223372036854775806, add: -9223372032559808514, sub: -9223372032559808510, mul: -8589934592, div: 0, mod: 4294967296},
+ itd64{a: 4294967296, b: 9223372036854775807, add: -9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 0, mod: 4294967296},
+ itd64{a: 9223372036854775806, b: -9223372036854775808, add: -2, sub: -2, mul: 0, div: 0, mod: 9223372036854775806},
+ itd64{a: 9223372036854775806, b: -9223372036854775807, add: -1, sub: -3, mul: 9223372036854775806, div: 0, mod: 9223372036854775806},
+ itd64{a: 9223372036854775806, b: -4294967296, add: 9223372032559808510, sub: -9223372032559808514, mul: 8589934592, div: -2147483647, mod: 4294967294},
+ itd64{a: 9223372036854775806, b: -1, add: 9223372036854775805, sub: 9223372036854775807, mul: -9223372036854775806, div: -9223372036854775806, mod: 0},
+ itd64{a: 9223372036854775806, b: 0, add: 9223372036854775806, sub: 9223372036854775806, mul: 0},
+ itd64{a: 9223372036854775806, b: 1, add: 9223372036854775807, sub: 9223372036854775805, mul: 9223372036854775806, div: 9223372036854775806, mod: 0},
+ itd64{a: 9223372036854775806, b: 4294967296, add: -9223372032559808514, sub: 9223372032559808510, mul: -8589934592, div: 2147483647, mod: 4294967294},
+ itd64{a: 9223372036854775806, b: 9223372036854775806, add: -4, sub: 0, mul: 4, div: 1, mod: 0},
+ itd64{a: 9223372036854775806, b: 9223372036854775807, add: -3, sub: -1, mul: -9223372036854775806, div: 0, mod: 9223372036854775806},
+ itd64{a: 9223372036854775807, b: -9223372036854775808, add: -1, sub: -1, mul: -9223372036854775808, div: 0, mod: 9223372036854775807},
+ itd64{a: 9223372036854775807, b: -9223372036854775807, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd64{a: 9223372036854775807, b: -4294967296, add: 9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: -2147483647, mod: 4294967295},
+ itd64{a: 9223372036854775807, b: -1, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: -9223372036854775807, mod: 0},
+ itd64{a: 9223372036854775807, b: 0, add: 9223372036854775807, sub: 9223372036854775807, mul: 0},
+ itd64{a: 9223372036854775807, b: 1, add: -9223372036854775808, sub: 9223372036854775806, mul: 9223372036854775807, div: 9223372036854775807, mod: 0},
+ itd64{a: 9223372036854775807, b: 4294967296, add: -9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 2147483647, mod: 4294967295},
+ itd64{a: 9223372036854775807, b: 9223372036854775806, add: -3, sub: 1, mul: -9223372036854775806, div: 1, mod: 1},
+ itd64{a: 9223372036854775807, b: 9223372036854775807, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var uint32_data []utd32 = []utd32{utd32{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ utd32{a: 0, b: 1, add: 1, sub: 4294967295, mul: 0, div: 0, mod: 0},
+ utd32{a: 0, b: 4294967295, add: 4294967295, sub: 1, mul: 0, div: 0, mod: 0},
+ utd32{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ utd32{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ utd32{a: 1, b: 4294967295, add: 0, sub: 2, mul: 4294967295, div: 0, mod: 1},
+ utd32{a: 4294967295, b: 0, add: 4294967295, sub: 4294967295, mul: 0},
+ utd32{a: 4294967295, b: 1, add: 0, sub: 4294967294, mul: 4294967295, div: 4294967295, mod: 0},
+ utd32{a: 4294967295, b: 4294967295, add: 4294967294, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var int32_data []itd32 = []itd32{itd32{a: -2147483648, b: -2147483648, add: 0, sub: 0, mul: 0, div: 1, mod: 0},
+ itd32{a: -2147483648, b: -2147483647, add: 1, sub: -1, mul: -2147483648, div: 1, mod: -1},
+ itd32{a: -2147483648, b: -1, add: 2147483647, sub: -2147483647, mul: -2147483648, div: -2147483648, mod: 0},
+ itd32{a: -2147483648, b: 0, add: -2147483648, sub: -2147483648, mul: 0},
+ itd32{a: -2147483648, b: 1, add: -2147483647, sub: 2147483647, mul: -2147483648, div: -2147483648, mod: 0},
+ itd32{a: -2147483648, b: 2147483647, add: -1, sub: 1, mul: -2147483648, div: -1, mod: -1},
+ itd32{a: -2147483647, b: -2147483648, add: 1, sub: 1, mul: -2147483648, div: 0, mod: -2147483647},
+ itd32{a: -2147483647, b: -2147483647, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd32{a: -2147483647, b: -1, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 2147483647, mod: 0},
+ itd32{a: -2147483647, b: 0, add: -2147483647, sub: -2147483647, mul: 0},
+ itd32{a: -2147483647, b: 1, add: -2147483646, sub: -2147483648, mul: -2147483647, div: -2147483647, mod: 0},
+ itd32{a: -2147483647, b: 2147483647, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd32{a: -1, b: -2147483648, add: 2147483647, sub: 2147483647, mul: -2147483648, div: 0, mod: -1},
+ itd32{a: -1, b: -2147483647, add: -2147483648, sub: 2147483646, mul: 2147483647, div: 0, mod: -1},
+ itd32{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd32{a: -1, b: 0, add: -1, sub: -1, mul: 0},
+ itd32{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd32{a: -1, b: 2147483647, add: 2147483646, sub: -2147483648, mul: -2147483647, div: 0, mod: -1},
+ itd32{a: 0, b: -2147483648, add: -2147483648, sub: -2147483648, mul: 0, div: 0, mod: 0},
+ itd32{a: 0, b: -2147483647, add: -2147483647, sub: 2147483647, mul: 0, div: 0, mod: 0},
+ itd32{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 0, mod: 0},
+ itd32{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ itd32{a: 0, b: 1, add: 1, sub: -1, mul: 0, div: 0, mod: 0},
+ itd32{a: 0, b: 2147483647, add: 2147483647, sub: -2147483647, mul: 0, div: 0, mod: 0},
+ itd32{a: 1, b: -2147483648, add: -2147483647, sub: -2147483647, mul: -2147483648, div: 0, mod: 1},
+ itd32{a: 1, b: -2147483647, add: -2147483646, sub: -2147483648, mul: -2147483647, div: 0, mod: 1},
+ itd32{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd32{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ itd32{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd32{a: 1, b: 2147483647, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 0, mod: 1},
+ itd32{a: 2147483647, b: -2147483648, add: -1, sub: -1, mul: -2147483648, div: 0, mod: 2147483647},
+ itd32{a: 2147483647, b: -2147483647, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd32{a: 2147483647, b: -1, add: 2147483646, sub: -2147483648, mul: -2147483647, div: -2147483647, mod: 0},
+ itd32{a: 2147483647, b: 0, add: 2147483647, sub: 2147483647, mul: 0},
+ itd32{a: 2147483647, b: 1, add: -2147483648, sub: 2147483646, mul: 2147483647, div: 2147483647, mod: 0},
+ itd32{a: 2147483647, b: 2147483647, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var uint16_data []utd16 = []utd16{utd16{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ utd16{a: 0, b: 1, add: 1, sub: 65535, mul: 0, div: 0, mod: 0},
+ utd16{a: 0, b: 65535, add: 65535, sub: 1, mul: 0, div: 0, mod: 0},
+ utd16{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ utd16{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ utd16{a: 1, b: 65535, add: 0, sub: 2, mul: 65535, div: 0, mod: 1},
+ utd16{a: 65535, b: 0, add: 65535, sub: 65535, mul: 0},
+ utd16{a: 65535, b: 1, add: 0, sub: 65534, mul: 65535, div: 65535, mod: 0},
+ utd16{a: 65535, b: 65535, add: 65534, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var int16_data []itd16 = []itd16{itd16{a: -32768, b: -32768, add: 0, sub: 0, mul: 0, div: 1, mod: 0},
+ itd16{a: -32768, b: -32767, add: 1, sub: -1, mul: -32768, div: 1, mod: -1},
+ itd16{a: -32768, b: -1, add: 32767, sub: -32767, mul: -32768, div: -32768, mod: 0},
+ itd16{a: -32768, b: 0, add: -32768, sub: -32768, mul: 0},
+ itd16{a: -32768, b: 1, add: -32767, sub: 32767, mul: -32768, div: -32768, mod: 0},
+ itd16{a: -32768, b: 32766, add: -2, sub: 2, mul: 0, div: -1, mod: -2},
+ itd16{a: -32768, b: 32767, add: -1, sub: 1, mul: -32768, div: -1, mod: -1},
+ itd16{a: -32767, b: -32768, add: 1, sub: 1, mul: -32768, div: 0, mod: -32767},
+ itd16{a: -32767, b: -32767, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd16{a: -32767, b: -1, add: -32768, sub: -32766, mul: 32767, div: 32767, mod: 0},
+ itd16{a: -32767, b: 0, add: -32767, sub: -32767, mul: 0},
+ itd16{a: -32767, b: 1, add: -32766, sub: -32768, mul: -32767, div: -32767, mod: 0},
+ itd16{a: -32767, b: 32766, add: -1, sub: 3, mul: 32766, div: -1, mod: -1},
+ itd16{a: -32767, b: 32767, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd16{a: -1, b: -32768, add: 32767, sub: 32767, mul: -32768, div: 0, mod: -1},
+ itd16{a: -1, b: -32767, add: -32768, sub: 32766, mul: 32767, div: 0, mod: -1},
+ itd16{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd16{a: -1, b: 0, add: -1, sub: -1, mul: 0},
+ itd16{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd16{a: -1, b: 32766, add: 32765, sub: -32767, mul: -32766, div: 0, mod: -1},
+ itd16{a: -1, b: 32767, add: 32766, sub: -32768, mul: -32767, div: 0, mod: -1},
+ itd16{a: 0, b: -32768, add: -32768, sub: -32768, mul: 0, div: 0, mod: 0},
+ itd16{a: 0, b: -32767, add: -32767, sub: 32767, mul: 0, div: 0, mod: 0},
+ itd16{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 0, mod: 0},
+ itd16{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ itd16{a: 0, b: 1, add: 1, sub: -1, mul: 0, div: 0, mod: 0},
+ itd16{a: 0, b: 32766, add: 32766, sub: -32766, mul: 0, div: 0, mod: 0},
+ itd16{a: 0, b: 32767, add: 32767, sub: -32767, mul: 0, div: 0, mod: 0},
+ itd16{a: 1, b: -32768, add: -32767, sub: -32767, mul: -32768, div: 0, mod: 1},
+ itd16{a: 1, b: -32767, add: -32766, sub: -32768, mul: -32767, div: 0, mod: 1},
+ itd16{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd16{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ itd16{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd16{a: 1, b: 32766, add: 32767, sub: -32765, mul: 32766, div: 0, mod: 1},
+ itd16{a: 1, b: 32767, add: -32768, sub: -32766, mul: 32767, div: 0, mod: 1},
+ itd16{a: 32766, b: -32768, add: -2, sub: -2, mul: 0, div: 0, mod: 32766},
+ itd16{a: 32766, b: -32767, add: -1, sub: -3, mul: 32766, div: 0, mod: 32766},
+ itd16{a: 32766, b: -1, add: 32765, sub: 32767, mul: -32766, div: -32766, mod: 0},
+ itd16{a: 32766, b: 0, add: 32766, sub: 32766, mul: 0},
+ itd16{a: 32766, b: 1, add: 32767, sub: 32765, mul: 32766, div: 32766, mod: 0},
+ itd16{a: 32766, b: 32766, add: -4, sub: 0, mul: 4, div: 1, mod: 0},
+ itd16{a: 32766, b: 32767, add: -3, sub: -1, mul: -32766, div: 0, mod: 32766},
+ itd16{a: 32767, b: -32768, add: -1, sub: -1, mul: -32768, div: 0, mod: 32767},
+ itd16{a: 32767, b: -32767, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd16{a: 32767, b: -1, add: 32766, sub: -32768, mul: -32767, div: -32767, mod: 0},
+ itd16{a: 32767, b: 0, add: 32767, sub: 32767, mul: 0},
+ itd16{a: 32767, b: 1, add: -32768, sub: 32766, mul: 32767, div: 32767, mod: 0},
+ itd16{a: 32767, b: 32766, add: -3, sub: 1, mul: -32766, div: 1, mod: 1},
+ itd16{a: 32767, b: 32767, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var uint8_data []utd8 = []utd8{utd8{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ utd8{a: 0, b: 1, add: 1, sub: 255, mul: 0, div: 0, mod: 0},
+ utd8{a: 0, b: 255, add: 255, sub: 1, mul: 0, div: 0, mod: 0},
+ utd8{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ utd8{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ utd8{a: 1, b: 255, add: 0, sub: 2, mul: 255, div: 0, mod: 1},
+ utd8{a: 255, b: 0, add: 255, sub: 255, mul: 0},
+ utd8{a: 255, b: 1, add: 0, sub: 254, mul: 255, div: 255, mod: 0},
+ utd8{a: 255, b: 255, add: 254, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var int8_data []itd8 = []itd8{itd8{a: -128, b: -128, add: 0, sub: 0, mul: 0, div: 1, mod: 0},
+ itd8{a: -128, b: -127, add: 1, sub: -1, mul: -128, div: 1, mod: -1},
+ itd8{a: -128, b: -1, add: 127, sub: -127, mul: -128, div: -128, mod: 0},
+ itd8{a: -128, b: 0, add: -128, sub: -128, mul: 0},
+ itd8{a: -128, b: 1, add: -127, sub: 127, mul: -128, div: -128, mod: 0},
+ itd8{a: -128, b: 126, add: -2, sub: 2, mul: 0, div: -1, mod: -2},
+ itd8{a: -128, b: 127, add: -1, sub: 1, mul: -128, div: -1, mod: -1},
+ itd8{a: -127, b: -128, add: 1, sub: 1, mul: -128, div: 0, mod: -127},
+ itd8{a: -127, b: -127, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd8{a: -127, b: -1, add: -128, sub: -126, mul: 127, div: 127, mod: 0},
+ itd8{a: -127, b: 0, add: -127, sub: -127, mul: 0},
+ itd8{a: -127, b: 1, add: -126, sub: -128, mul: -127, div: -127, mod: 0},
+ itd8{a: -127, b: 126, add: -1, sub: 3, mul: 126, div: -1, mod: -1},
+ itd8{a: -127, b: 127, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd8{a: -1, b: -128, add: 127, sub: 127, mul: -128, div: 0, mod: -1},
+ itd8{a: -1, b: -127, add: -128, sub: 126, mul: 127, div: 0, mod: -1},
+ itd8{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd8{a: -1, b: 0, add: -1, sub: -1, mul: 0},
+ itd8{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd8{a: -1, b: 126, add: 125, sub: -127, mul: -126, div: 0, mod: -1},
+ itd8{a: -1, b: 127, add: 126, sub: -128, mul: -127, div: 0, mod: -1},
+ itd8{a: 0, b: -128, add: -128, sub: -128, mul: 0, div: 0, mod: 0},
+ itd8{a: 0, b: -127, add: -127, sub: 127, mul: 0, div: 0, mod: 0},
+ itd8{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 0, mod: 0},
+ itd8{a: 0, b: 0, add: 0, sub: 0, mul: 0},
+ itd8{a: 0, b: 1, add: 1, sub: -1, mul: 0, div: 0, mod: 0},
+ itd8{a: 0, b: 126, add: 126, sub: -126, mul: 0, div: 0, mod: 0},
+ itd8{a: 0, b: 127, add: 127, sub: -127, mul: 0, div: 0, mod: 0},
+ itd8{a: 1, b: -128, add: -127, sub: -127, mul: -128, div: 0, mod: 1},
+ itd8{a: 1, b: -127, add: -126, sub: -128, mul: -127, div: 0, mod: 1},
+ itd8{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1, mod: 0},
+ itd8{a: 1, b: 0, add: 1, sub: 1, mul: 0},
+ itd8{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1, mod: 0},
+ itd8{a: 1, b: 126, add: 127, sub: -125, mul: 126, div: 0, mod: 1},
+ itd8{a: 1, b: 127, add: -128, sub: -126, mul: 127, div: 0, mod: 1},
+ itd8{a: 126, b: -128, add: -2, sub: -2, mul: 0, div: 0, mod: 126},
+ itd8{a: 126, b: -127, add: -1, sub: -3, mul: 126, div: 0, mod: 126},
+ itd8{a: 126, b: -1, add: 125, sub: 127, mul: -126, div: -126, mod: 0},
+ itd8{a: 126, b: 0, add: 126, sub: 126, mul: 0},
+ itd8{a: 126, b: 1, add: 127, sub: 125, mul: 126, div: 126, mod: 0},
+ itd8{a: 126, b: 126, add: -4, sub: 0, mul: 4, div: 1, mod: 0},
+ itd8{a: 126, b: 127, add: -3, sub: -1, mul: -126, div: 0, mod: 126},
+ itd8{a: 127, b: -128, add: -1, sub: -1, mul: -128, div: 0, mod: 127},
+ itd8{a: 127, b: -127, add: 0, sub: -2, mul: -1, div: -1, mod: 0},
+ itd8{a: 127, b: -1, add: 126, sub: -128, mul: -127, div: -127, mod: 0},
+ itd8{a: 127, b: 0, add: 127, sub: 127, mul: 0},
+ itd8{a: 127, b: 1, add: -128, sub: 126, mul: 127, div: 127, mod: 0},
+ itd8{a: 127, b: 126, add: -3, sub: 1, mul: -126, div: 1, mod: 1},
+ itd8{a: 127, b: 127, add: -2, sub: 0, mul: 1, div: 1, mod: 0},
+}
+var failed bool
+
+func main() {
+
+ for _, v := range uint64_data {
+ if got := add_uint64_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_uint64 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_uint64_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_uint64 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_uint64_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_uint64 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_uint64_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_uint64 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_uint64_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_uint64 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range int64_data {
+ if got := add_int64_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_int64 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_int64_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_int64 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_int64_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_int64 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_int64_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_int64 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_int64_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_int64 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range uint32_data {
+ if got := add_uint32_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_uint32 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_uint32_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_uint32 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_uint32_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_uint32 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_uint32_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_uint32 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_uint32_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_uint32 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range int32_data {
+ if got := add_int32_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_int32 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_int32_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_int32 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_int32_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_int32 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_int32_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_int32 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_int32_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_int32 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range uint16_data {
+ if got := add_uint16_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_uint16 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_uint16_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_uint16 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_uint16_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_uint16 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_uint16_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_uint16 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_uint16_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_uint16 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range int16_data {
+ if got := add_int16_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_int16 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_int16_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_int16 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_int16_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_int16 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_int16_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_int16 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_int16_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_int16 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range uint8_data {
+ if got := add_uint8_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_uint8 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_uint8_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_uint8 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_uint8_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_uint8 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_uint8_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_uint8 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_uint8_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_uint8 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ for _, v := range int8_data {
+ if got := add_int8_ssa(v.a, v.b); got != v.add {
+ fmt.Printf("add_int8 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
+ failed = true
+ }
+ if got := sub_int8_ssa(v.a, v.b); got != v.sub {
+ fmt.Printf("sub_int8 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
+ failed = true
+ }
+ if v.b != 0 {
+ if got := div_int8_ssa(v.a, v.b); got != v.div {
+ fmt.Printf("div_int8 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
+ failed = true
+ }
+
+ }
+ if v.b != 0 {
+ if got := mod_int8_ssa(v.a, v.b); got != v.mod {
+ fmt.Printf("mod_int8 %d%%%d = %d, wanted %d\n", v.a, v.b, got, v.mod)
+ failed = true
+ }
+
+ }
+ if got := mul_int8_ssa(v.a, v.b); got != v.mul {
+ fmt.Printf("mul_int8 %d*%d = %d, wanted %d\n", v.a, v.b, got, v.mul)
+ failed = true
+ }
+ }
+ if failed {
+ panic("tests failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go b/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go
new file mode 100644
index 0000000..782d2df
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go
@@ -0,0 +1,12671 @@
+package main
+
+import "fmt"
+
+//go:noinline
+func add_uint64_0_ssa(a uint64) uint64 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_uint64_ssa(a uint64) uint64 {
+ return 0 + a
+}
+
+//go:noinline
+func add_uint64_1_ssa(a uint64) uint64 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_uint64_ssa(a uint64) uint64 {
+ return 1 + a
+}
+
+//go:noinline
+func add_uint64_4294967296_ssa(a uint64) uint64 {
+ return a + 4294967296
+}
+
+//go:noinline
+func add_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 + a
+}
+
+//go:noinline
+func add_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a + 18446744073709551615
+}
+
+//go:noinline
+func add_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 + a
+}
+
+//go:noinline
+func sub_uint64_0_ssa(a uint64) uint64 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_uint64_ssa(a uint64) uint64 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_uint64_1_ssa(a uint64) uint64 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_uint64_ssa(a uint64) uint64 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_uint64_4294967296_ssa(a uint64) uint64 {
+ return a - 4294967296
+}
+
+//go:noinline
+func sub_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 - a
+}
+
+//go:noinline
+func sub_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a - 18446744073709551615
+}
+
+//go:noinline
+func sub_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 - a
+}
+
+//go:noinline
+func div_0_uint64_ssa(a uint64) uint64 {
+ return 0 / a
+}
+
+//go:noinline
+func div_uint64_1_ssa(a uint64) uint64 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_uint64_ssa(a uint64) uint64 {
+ return 1 / a
+}
+
+//go:noinline
+func div_uint64_4294967296_ssa(a uint64) uint64 {
+ return a / 4294967296
+}
+
+//go:noinline
+func div_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 / a
+}
+
+//go:noinline
+func div_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a / 18446744073709551615
+}
+
+//go:noinline
+func div_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 / a
+}
+
+//go:noinline
+func mul_uint64_0_ssa(a uint64) uint64 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_uint64_ssa(a uint64) uint64 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_uint64_1_ssa(a uint64) uint64 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_uint64_ssa(a uint64) uint64 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_uint64_4294967296_ssa(a uint64) uint64 {
+ return a * 4294967296
+}
+
+//go:noinline
+func mul_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 * a
+}
+
+//go:noinline
+func mul_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a * 18446744073709551615
+}
+
+//go:noinline
+func mul_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 * a
+}
+
+//go:noinline
+func lsh_uint64_0_ssa(a uint64) uint64 {
+ return a << 0
+}
+
+//go:noinline
+func lsh_0_uint64_ssa(a uint64) uint64 {
+ return 0 << a
+}
+
+//go:noinline
+func lsh_uint64_1_ssa(a uint64) uint64 {
+ return a << 1
+}
+
+//go:noinline
+func lsh_1_uint64_ssa(a uint64) uint64 {
+ return 1 << a
+}
+
+//go:noinline
+func lsh_uint64_4294967296_ssa(a uint64) uint64 {
+ return a << 4294967296
+}
+
+//go:noinline
+func lsh_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 << a
+}
+
+//go:noinline
+func lsh_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a << 18446744073709551615
+}
+
+//go:noinline
+func lsh_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 << a
+}
+
+//go:noinline
+func rsh_uint64_0_ssa(a uint64) uint64 {
+ return a >> 0
+}
+
+//go:noinline
+func rsh_0_uint64_ssa(a uint64) uint64 {
+ return 0 >> a
+}
+
+//go:noinline
+func rsh_uint64_1_ssa(a uint64) uint64 {
+ return a >> 1
+}
+
+//go:noinline
+func rsh_1_uint64_ssa(a uint64) uint64 {
+ return 1 >> a
+}
+
+//go:noinline
+func rsh_uint64_4294967296_ssa(a uint64) uint64 {
+ return a >> 4294967296
+}
+
+//go:noinline
+func rsh_4294967296_uint64_ssa(a uint64) uint64 {
+ return 4294967296 >> a
+}
+
+//go:noinline
+func rsh_uint64_18446744073709551615_ssa(a uint64) uint64 {
+ return a >> 18446744073709551615
+}
+
+//go:noinline
+func rsh_18446744073709551615_uint64_ssa(a uint64) uint64 {
+ return 18446744073709551615 >> a
+}
+
+//go:noinline
+func add_int64_Neg9223372036854775808_ssa(a int64) int64 {
+ return a + -9223372036854775808
+}
+
+//go:noinline
+func add_Neg9223372036854775808_int64_ssa(a int64) int64 {
+ return -9223372036854775808 + a
+}
+
+//go:noinline
+func add_int64_Neg9223372036854775807_ssa(a int64) int64 {
+ return a + -9223372036854775807
+}
+
+//go:noinline
+func add_Neg9223372036854775807_int64_ssa(a int64) int64 {
+ return -9223372036854775807 + a
+}
+
+//go:noinline
+func add_int64_Neg4294967296_ssa(a int64) int64 {
+ return a + -4294967296
+}
+
+//go:noinline
+func add_Neg4294967296_int64_ssa(a int64) int64 {
+ return -4294967296 + a
+}
+
+//go:noinline
+func add_int64_Neg1_ssa(a int64) int64 {
+ return a + -1
+}
+
+//go:noinline
+func add_Neg1_int64_ssa(a int64) int64 {
+ return -1 + a
+}
+
+//go:noinline
+func add_int64_0_ssa(a int64) int64 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_int64_ssa(a int64) int64 {
+ return 0 + a
+}
+
+//go:noinline
+func add_int64_1_ssa(a int64) int64 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_int64_ssa(a int64) int64 {
+ return 1 + a
+}
+
+//go:noinline
+func add_int64_4294967296_ssa(a int64) int64 {
+ return a + 4294967296
+}
+
+//go:noinline
+func add_4294967296_int64_ssa(a int64) int64 {
+ return 4294967296 + a
+}
+
+//go:noinline
+func add_int64_9223372036854775806_ssa(a int64) int64 {
+ return a + 9223372036854775806
+}
+
+//go:noinline
+func add_9223372036854775806_int64_ssa(a int64) int64 {
+ return 9223372036854775806 + a
+}
+
+//go:noinline
+func add_int64_9223372036854775807_ssa(a int64) int64 {
+ return a + 9223372036854775807
+}
+
+//go:noinline
+func add_9223372036854775807_int64_ssa(a int64) int64 {
+ return 9223372036854775807 + a
+}
+
+//go:noinline
+func sub_int64_Neg9223372036854775808_ssa(a int64) int64 {
+ return a - -9223372036854775808
+}
+
+//go:noinline
+func sub_Neg9223372036854775808_int64_ssa(a int64) int64 {
+ return -9223372036854775808 - a
+}
+
+//go:noinline
+func sub_int64_Neg9223372036854775807_ssa(a int64) int64 {
+ return a - -9223372036854775807
+}
+
+//go:noinline
+func sub_Neg9223372036854775807_int64_ssa(a int64) int64 {
+ return -9223372036854775807 - a
+}
+
+//go:noinline
+func sub_int64_Neg4294967296_ssa(a int64) int64 {
+ return a - -4294967296
+}
+
+//go:noinline
+func sub_Neg4294967296_int64_ssa(a int64) int64 {
+ return -4294967296 - a
+}
+
+//go:noinline
+func sub_int64_Neg1_ssa(a int64) int64 {
+ return a - -1
+}
+
+//go:noinline
+func sub_Neg1_int64_ssa(a int64) int64 {
+ return -1 - a
+}
+
+//go:noinline
+func sub_int64_0_ssa(a int64) int64 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_int64_ssa(a int64) int64 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_int64_1_ssa(a int64) int64 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_int64_ssa(a int64) int64 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_int64_4294967296_ssa(a int64) int64 {
+ return a - 4294967296
+}
+
+//go:noinline
+func sub_4294967296_int64_ssa(a int64) int64 {
+ return 4294967296 - a
+}
+
+//go:noinline
+func sub_int64_9223372036854775806_ssa(a int64) int64 {
+ return a - 9223372036854775806
+}
+
+//go:noinline
+func sub_9223372036854775806_int64_ssa(a int64) int64 {
+ return 9223372036854775806 - a
+}
+
+//go:noinline
+func sub_int64_9223372036854775807_ssa(a int64) int64 {
+ return a - 9223372036854775807
+}
+
+//go:noinline
+func sub_9223372036854775807_int64_ssa(a int64) int64 {
+ return 9223372036854775807 - a
+}
+
+//go:noinline
+func div_int64_Neg9223372036854775808_ssa(a int64) int64 {
+ return a / -9223372036854775808
+}
+
+//go:noinline
+func div_Neg9223372036854775808_int64_ssa(a int64) int64 {
+ return -9223372036854775808 / a
+}
+
+//go:noinline
+func div_int64_Neg9223372036854775807_ssa(a int64) int64 {
+ return a / -9223372036854775807
+}
+
+//go:noinline
+func div_Neg9223372036854775807_int64_ssa(a int64) int64 {
+ return -9223372036854775807 / a
+}
+
+//go:noinline
+func div_int64_Neg4294967296_ssa(a int64) int64 {
+ return a / -4294967296
+}
+
+//go:noinline
+func div_Neg4294967296_int64_ssa(a int64) int64 {
+ return -4294967296 / a
+}
+
+//go:noinline
+func div_int64_Neg1_ssa(a int64) int64 {
+ return a / -1
+}
+
+//go:noinline
+func div_Neg1_int64_ssa(a int64) int64 {
+ return -1 / a
+}
+
+//go:noinline
+func div_0_int64_ssa(a int64) int64 {
+ return 0 / a
+}
+
+//go:noinline
+func div_int64_1_ssa(a int64) int64 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_int64_ssa(a int64) int64 {
+ return 1 / a
+}
+
+//go:noinline
+func div_int64_4294967296_ssa(a int64) int64 {
+ return a / 4294967296
+}
+
+//go:noinline
+func div_4294967296_int64_ssa(a int64) int64 {
+ return 4294967296 / a
+}
+
+//go:noinline
+func div_int64_9223372036854775806_ssa(a int64) int64 {
+ return a / 9223372036854775806
+}
+
+//go:noinline
+func div_9223372036854775806_int64_ssa(a int64) int64 {
+ return 9223372036854775806 / a
+}
+
+//go:noinline
+func div_int64_9223372036854775807_ssa(a int64) int64 {
+ return a / 9223372036854775807
+}
+
+//go:noinline
+func div_9223372036854775807_int64_ssa(a int64) int64 {
+ return 9223372036854775807 / a
+}
+
+//go:noinline
+func mul_int64_Neg9223372036854775808_ssa(a int64) int64 {
+ return a * -9223372036854775808
+}
+
+//go:noinline
+func mul_Neg9223372036854775808_int64_ssa(a int64) int64 {
+ return -9223372036854775808 * a
+}
+
+//go:noinline
+func mul_int64_Neg9223372036854775807_ssa(a int64) int64 {
+ return a * -9223372036854775807
+}
+
+//go:noinline
+func mul_Neg9223372036854775807_int64_ssa(a int64) int64 {
+ return -9223372036854775807 * a
+}
+
+//go:noinline
+func mul_int64_Neg4294967296_ssa(a int64) int64 {
+ return a * -4294967296
+}
+
+//go:noinline
+func mul_Neg4294967296_int64_ssa(a int64) int64 {
+ return -4294967296 * a
+}
+
+//go:noinline
+func mul_int64_Neg1_ssa(a int64) int64 {
+ return a * -1
+}
+
+//go:noinline
+func mul_Neg1_int64_ssa(a int64) int64 {
+ return -1 * a
+}
+
+//go:noinline
+func mul_int64_0_ssa(a int64) int64 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_int64_ssa(a int64) int64 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_int64_1_ssa(a int64) int64 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_int64_ssa(a int64) int64 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_int64_4294967296_ssa(a int64) int64 {
+ return a * 4294967296
+}
+
+//go:noinline
+func mul_4294967296_int64_ssa(a int64) int64 {
+ return 4294967296 * a
+}
+
+//go:noinline
+func mul_int64_9223372036854775806_ssa(a int64) int64 {
+ return a * 9223372036854775806
+}
+
+//go:noinline
+func mul_9223372036854775806_int64_ssa(a int64) int64 {
+ return 9223372036854775806 * a
+}
+
+//go:noinline
+func mul_int64_9223372036854775807_ssa(a int64) int64 {
+ return a * 9223372036854775807
+}
+
+//go:noinline
+func mul_9223372036854775807_int64_ssa(a int64) int64 {
+ return 9223372036854775807 * a
+}
+
+//go:noinline
+func add_uint32_0_ssa(a uint32) uint32 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_uint32_ssa(a uint32) uint32 {
+ return 0 + a
+}
+
+//go:noinline
+func add_uint32_1_ssa(a uint32) uint32 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_uint32_ssa(a uint32) uint32 {
+ return 1 + a
+}
+
+//go:noinline
+func add_uint32_4294967295_ssa(a uint32) uint32 {
+ return a + 4294967295
+}
+
+//go:noinline
+func add_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 + a
+}
+
+//go:noinline
+func sub_uint32_0_ssa(a uint32) uint32 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_uint32_ssa(a uint32) uint32 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_uint32_1_ssa(a uint32) uint32 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_uint32_ssa(a uint32) uint32 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_uint32_4294967295_ssa(a uint32) uint32 {
+ return a - 4294967295
+}
+
+//go:noinline
+func sub_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 - a
+}
+
+//go:noinline
+func div_0_uint32_ssa(a uint32) uint32 {
+ return 0 / a
+}
+
+//go:noinline
+func div_uint32_1_ssa(a uint32) uint32 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_uint32_ssa(a uint32) uint32 {
+ return 1 / a
+}
+
+//go:noinline
+func div_uint32_4294967295_ssa(a uint32) uint32 {
+ return a / 4294967295
+}
+
+//go:noinline
+func div_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 / a
+}
+
+//go:noinline
+func mul_uint32_0_ssa(a uint32) uint32 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_uint32_ssa(a uint32) uint32 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_uint32_1_ssa(a uint32) uint32 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_uint32_ssa(a uint32) uint32 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_uint32_4294967295_ssa(a uint32) uint32 {
+ return a * 4294967295
+}
+
+//go:noinline
+func mul_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 * a
+}
+
+//go:noinline
+func lsh_uint32_0_ssa(a uint32) uint32 {
+ return a << 0
+}
+
+//go:noinline
+func lsh_0_uint32_ssa(a uint32) uint32 {
+ return 0 << a
+}
+
+//go:noinline
+func lsh_uint32_1_ssa(a uint32) uint32 {
+ return a << 1
+}
+
+//go:noinline
+func lsh_1_uint32_ssa(a uint32) uint32 {
+ return 1 << a
+}
+
+//go:noinline
+func lsh_uint32_4294967295_ssa(a uint32) uint32 {
+ return a << 4294967295
+}
+
+//go:noinline
+func lsh_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 << a
+}
+
+//go:noinline
+func rsh_uint32_0_ssa(a uint32) uint32 {
+ return a >> 0
+}
+
+//go:noinline
+func rsh_0_uint32_ssa(a uint32) uint32 {
+ return 0 >> a
+}
+
+//go:noinline
+func rsh_uint32_1_ssa(a uint32) uint32 {
+ return a >> 1
+}
+
+//go:noinline
+func rsh_1_uint32_ssa(a uint32) uint32 {
+ return 1 >> a
+}
+
+//go:noinline
+func rsh_uint32_4294967295_ssa(a uint32) uint32 {
+ return a >> 4294967295
+}
+
+//go:noinline
+func rsh_4294967295_uint32_ssa(a uint32) uint32 {
+ return 4294967295 >> a
+}
+
+//go:noinline
+func add_int32_Neg2147483648_ssa(a int32) int32 {
+ return a + -2147483648
+}
+
+//go:noinline
+func add_Neg2147483648_int32_ssa(a int32) int32 {
+ return -2147483648 + a
+}
+
+//go:noinline
+func add_int32_Neg2147483647_ssa(a int32) int32 {
+ return a + -2147483647
+}
+
+//go:noinline
+func add_Neg2147483647_int32_ssa(a int32) int32 {
+ return -2147483647 + a
+}
+
+//go:noinline
+func add_int32_Neg1_ssa(a int32) int32 {
+ return a + -1
+}
+
+//go:noinline
+func add_Neg1_int32_ssa(a int32) int32 {
+ return -1 + a
+}
+
+//go:noinline
+func add_int32_0_ssa(a int32) int32 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_int32_ssa(a int32) int32 {
+ return 0 + a
+}
+
+//go:noinline
+func add_int32_1_ssa(a int32) int32 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_int32_ssa(a int32) int32 {
+ return 1 + a
+}
+
+//go:noinline
+func add_int32_2147483647_ssa(a int32) int32 {
+ return a + 2147483647
+}
+
+//go:noinline
+func add_2147483647_int32_ssa(a int32) int32 {
+ return 2147483647 + a
+}
+
+//go:noinline
+func sub_int32_Neg2147483648_ssa(a int32) int32 {
+ return a - -2147483648
+}
+
+//go:noinline
+func sub_Neg2147483648_int32_ssa(a int32) int32 {
+ return -2147483648 - a
+}
+
+//go:noinline
+func sub_int32_Neg2147483647_ssa(a int32) int32 {
+ return a - -2147483647
+}
+
+//go:noinline
+func sub_Neg2147483647_int32_ssa(a int32) int32 {
+ return -2147483647 - a
+}
+
+//go:noinline
+func sub_int32_Neg1_ssa(a int32) int32 {
+ return a - -1
+}
+
+//go:noinline
+func sub_Neg1_int32_ssa(a int32) int32 {
+ return -1 - a
+}
+
+//go:noinline
+func sub_int32_0_ssa(a int32) int32 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_int32_ssa(a int32) int32 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_int32_1_ssa(a int32) int32 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_int32_ssa(a int32) int32 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_int32_2147483647_ssa(a int32) int32 {
+ return a - 2147483647
+}
+
+//go:noinline
+func sub_2147483647_int32_ssa(a int32) int32 {
+ return 2147483647 - a
+}
+
+//go:noinline
+func div_int32_Neg2147483648_ssa(a int32) int32 {
+ return a / -2147483648
+}
+
+//go:noinline
+func div_Neg2147483648_int32_ssa(a int32) int32 {
+ return -2147483648 / a
+}
+
+//go:noinline
+func div_int32_Neg2147483647_ssa(a int32) int32 {
+ return a / -2147483647
+}
+
+//go:noinline
+func div_Neg2147483647_int32_ssa(a int32) int32 {
+ return -2147483647 / a
+}
+
+//go:noinline
+func div_int32_Neg1_ssa(a int32) int32 {
+ return a / -1
+}
+
+//go:noinline
+func div_Neg1_int32_ssa(a int32) int32 {
+ return -1 / a
+}
+
+//go:noinline
+func div_0_int32_ssa(a int32) int32 {
+ return 0 / a
+}
+
+//go:noinline
+func div_int32_1_ssa(a int32) int32 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_int32_ssa(a int32) int32 {
+ return 1 / a
+}
+
+//go:noinline
+func div_int32_2147483647_ssa(a int32) int32 {
+ return a / 2147483647
+}
+
+//go:noinline
+func div_2147483647_int32_ssa(a int32) int32 {
+ return 2147483647 / a
+}
+
+//go:noinline
+func mul_int32_Neg2147483648_ssa(a int32) int32 {
+ return a * -2147483648
+}
+
+//go:noinline
+func mul_Neg2147483648_int32_ssa(a int32) int32 {
+ return -2147483648 * a
+}
+
+//go:noinline
+func mul_int32_Neg2147483647_ssa(a int32) int32 {
+ return a * -2147483647
+}
+
+//go:noinline
+func mul_Neg2147483647_int32_ssa(a int32) int32 {
+ return -2147483647 * a
+}
+
+//go:noinline
+func mul_int32_Neg1_ssa(a int32) int32 {
+ return a * -1
+}
+
+//go:noinline
+func mul_Neg1_int32_ssa(a int32) int32 {
+ return -1 * a
+}
+
+//go:noinline
+func mul_int32_0_ssa(a int32) int32 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_int32_ssa(a int32) int32 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_int32_1_ssa(a int32) int32 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_int32_ssa(a int32) int32 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_int32_2147483647_ssa(a int32) int32 {
+ return a * 2147483647
+}
+
+//go:noinline
+func mul_2147483647_int32_ssa(a int32) int32 {
+ return 2147483647 * a
+}
+
+//go:noinline
+func add_uint16_0_ssa(a uint16) uint16 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_uint16_ssa(a uint16) uint16 {
+ return 0 + a
+}
+
+//go:noinline
+func add_uint16_1_ssa(a uint16) uint16 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_uint16_ssa(a uint16) uint16 {
+ return 1 + a
+}
+
+//go:noinline
+func add_uint16_65535_ssa(a uint16) uint16 {
+ return a + 65535
+}
+
+//go:noinline
+func add_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 + a
+}
+
+//go:noinline
+func sub_uint16_0_ssa(a uint16) uint16 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_uint16_ssa(a uint16) uint16 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_uint16_1_ssa(a uint16) uint16 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_uint16_ssa(a uint16) uint16 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_uint16_65535_ssa(a uint16) uint16 {
+ return a - 65535
+}
+
+//go:noinline
+func sub_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 - a
+}
+
+//go:noinline
+func div_0_uint16_ssa(a uint16) uint16 {
+ return 0 / a
+}
+
+//go:noinline
+func div_uint16_1_ssa(a uint16) uint16 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_uint16_ssa(a uint16) uint16 {
+ return 1 / a
+}
+
+//go:noinline
+func div_uint16_65535_ssa(a uint16) uint16 {
+ return a / 65535
+}
+
+//go:noinline
+func div_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 / a
+}
+
+//go:noinline
+func mul_uint16_0_ssa(a uint16) uint16 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_uint16_ssa(a uint16) uint16 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_uint16_1_ssa(a uint16) uint16 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_uint16_ssa(a uint16) uint16 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_uint16_65535_ssa(a uint16) uint16 {
+ return a * 65535
+}
+
+//go:noinline
+func mul_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 * a
+}
+
+//go:noinline
+func lsh_uint16_0_ssa(a uint16) uint16 {
+ return a << 0
+}
+
+//go:noinline
+func lsh_0_uint16_ssa(a uint16) uint16 {
+ return 0 << a
+}
+
+//go:noinline
+func lsh_uint16_1_ssa(a uint16) uint16 {
+ return a << 1
+}
+
+//go:noinline
+func lsh_1_uint16_ssa(a uint16) uint16 {
+ return 1 << a
+}
+
+//go:noinline
+func lsh_uint16_65535_ssa(a uint16) uint16 {
+ return a << 65535
+}
+
+//go:noinline
+func lsh_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 << a
+}
+
+//go:noinline
+func rsh_uint16_0_ssa(a uint16) uint16 {
+ return a >> 0
+}
+
+//go:noinline
+func rsh_0_uint16_ssa(a uint16) uint16 {
+ return 0 >> a
+}
+
+//go:noinline
+func rsh_uint16_1_ssa(a uint16) uint16 {
+ return a >> 1
+}
+
+//go:noinline
+func rsh_1_uint16_ssa(a uint16) uint16 {
+ return 1 >> a
+}
+
+//go:noinline
+func rsh_uint16_65535_ssa(a uint16) uint16 {
+ return a >> 65535
+}
+
+//go:noinline
+func rsh_65535_uint16_ssa(a uint16) uint16 {
+ return 65535 >> a
+}
+
+//go:noinline
+func add_int16_Neg32768_ssa(a int16) int16 {
+ return a + -32768
+}
+
+//go:noinline
+func add_Neg32768_int16_ssa(a int16) int16 {
+ return -32768 + a
+}
+
+//go:noinline
+func add_int16_Neg32767_ssa(a int16) int16 {
+ return a + -32767
+}
+
+//go:noinline
+func add_Neg32767_int16_ssa(a int16) int16 {
+ return -32767 + a
+}
+
+//go:noinline
+func add_int16_Neg1_ssa(a int16) int16 {
+ return a + -1
+}
+
+//go:noinline
+func add_Neg1_int16_ssa(a int16) int16 {
+ return -1 + a
+}
+
+//go:noinline
+func add_int16_0_ssa(a int16) int16 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_int16_ssa(a int16) int16 {
+ return 0 + a
+}
+
+//go:noinline
+func add_int16_1_ssa(a int16) int16 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_int16_ssa(a int16) int16 {
+ return 1 + a
+}
+
+//go:noinline
+func add_int16_32766_ssa(a int16) int16 {
+ return a + 32766
+}
+
+//go:noinline
+func add_32766_int16_ssa(a int16) int16 {
+ return 32766 + a
+}
+
+//go:noinline
+func add_int16_32767_ssa(a int16) int16 {
+ return a + 32767
+}
+
+//go:noinline
+func add_32767_int16_ssa(a int16) int16 {
+ return 32767 + a
+}
+
+//go:noinline
+func sub_int16_Neg32768_ssa(a int16) int16 {
+ return a - -32768
+}
+
+//go:noinline
+func sub_Neg32768_int16_ssa(a int16) int16 {
+ return -32768 - a
+}
+
+//go:noinline
+func sub_int16_Neg32767_ssa(a int16) int16 {
+ return a - -32767
+}
+
+//go:noinline
+func sub_Neg32767_int16_ssa(a int16) int16 {
+ return -32767 - a
+}
+
+//go:noinline
+func sub_int16_Neg1_ssa(a int16) int16 {
+ return a - -1
+}
+
+//go:noinline
+func sub_Neg1_int16_ssa(a int16) int16 {
+ return -1 - a
+}
+
+//go:noinline
+func sub_int16_0_ssa(a int16) int16 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_int16_ssa(a int16) int16 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_int16_1_ssa(a int16) int16 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_int16_ssa(a int16) int16 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_int16_32766_ssa(a int16) int16 {
+ return a - 32766
+}
+
+//go:noinline
+func sub_32766_int16_ssa(a int16) int16 {
+ return 32766 - a
+}
+
+//go:noinline
+func sub_int16_32767_ssa(a int16) int16 {
+ return a - 32767
+}
+
+//go:noinline
+func sub_32767_int16_ssa(a int16) int16 {
+ return 32767 - a
+}
+
+//go:noinline
+func div_int16_Neg32768_ssa(a int16) int16 {
+ return a / -32768
+}
+
+//go:noinline
+func div_Neg32768_int16_ssa(a int16) int16 {
+ return -32768 / a
+}
+
+//go:noinline
+func div_int16_Neg32767_ssa(a int16) int16 {
+ return a / -32767
+}
+
+//go:noinline
+func div_Neg32767_int16_ssa(a int16) int16 {
+ return -32767 / a
+}
+
+//go:noinline
+func div_int16_Neg1_ssa(a int16) int16 {
+ return a / -1
+}
+
+//go:noinline
+func div_Neg1_int16_ssa(a int16) int16 {
+ return -1 / a
+}
+
+//go:noinline
+func div_0_int16_ssa(a int16) int16 {
+ return 0 / a
+}
+
+//go:noinline
+func div_int16_1_ssa(a int16) int16 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_int16_ssa(a int16) int16 {
+ return 1 / a
+}
+
+//go:noinline
+func div_int16_32766_ssa(a int16) int16 {
+ return a / 32766
+}
+
+//go:noinline
+func div_32766_int16_ssa(a int16) int16 {
+ return 32766 / a
+}
+
+//go:noinline
+func div_int16_32767_ssa(a int16) int16 {
+ return a / 32767
+}
+
+//go:noinline
+func div_32767_int16_ssa(a int16) int16 {
+ return 32767 / a
+}
+
+//go:noinline
+func mul_int16_Neg32768_ssa(a int16) int16 {
+ return a * -32768
+}
+
+//go:noinline
+func mul_Neg32768_int16_ssa(a int16) int16 {
+ return -32768 * a
+}
+
+//go:noinline
+func mul_int16_Neg32767_ssa(a int16) int16 {
+ return a * -32767
+}
+
+//go:noinline
+func mul_Neg32767_int16_ssa(a int16) int16 {
+ return -32767 * a
+}
+
+//go:noinline
+func mul_int16_Neg1_ssa(a int16) int16 {
+ return a * -1
+}
+
+//go:noinline
+func mul_Neg1_int16_ssa(a int16) int16 {
+ return -1 * a
+}
+
+//go:noinline
+func mul_int16_0_ssa(a int16) int16 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_int16_ssa(a int16) int16 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_int16_1_ssa(a int16) int16 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_int16_ssa(a int16) int16 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_int16_32766_ssa(a int16) int16 {
+ return a * 32766
+}
+
+//go:noinline
+func mul_32766_int16_ssa(a int16) int16 {
+ return 32766 * a
+}
+
+//go:noinline
+func mul_int16_32767_ssa(a int16) int16 {
+ return a * 32767
+}
+
+//go:noinline
+func mul_32767_int16_ssa(a int16) int16 {
+ return 32767 * a
+}
+
+//go:noinline
+func add_uint8_0_ssa(a uint8) uint8 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_uint8_ssa(a uint8) uint8 {
+ return 0 + a
+}
+
+//go:noinline
+func add_uint8_1_ssa(a uint8) uint8 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_uint8_ssa(a uint8) uint8 {
+ return 1 + a
+}
+
+//go:noinline
+func add_uint8_255_ssa(a uint8) uint8 {
+ return a + 255
+}
+
+//go:noinline
+func add_255_uint8_ssa(a uint8) uint8 {
+ return 255 + a
+}
+
+//go:noinline
+func sub_uint8_0_ssa(a uint8) uint8 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_uint8_ssa(a uint8) uint8 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_uint8_1_ssa(a uint8) uint8 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_uint8_ssa(a uint8) uint8 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_uint8_255_ssa(a uint8) uint8 {
+ return a - 255
+}
+
+//go:noinline
+func sub_255_uint8_ssa(a uint8) uint8 {
+ return 255 - a
+}
+
+//go:noinline
+func div_0_uint8_ssa(a uint8) uint8 {
+ return 0 / a
+}
+
+//go:noinline
+func div_uint8_1_ssa(a uint8) uint8 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_uint8_ssa(a uint8) uint8 {
+ return 1 / a
+}
+
+//go:noinline
+func div_uint8_255_ssa(a uint8) uint8 {
+ return a / 255
+}
+
+//go:noinline
+func div_255_uint8_ssa(a uint8) uint8 {
+ return 255 / a
+}
+
+//go:noinline
+func mul_uint8_0_ssa(a uint8) uint8 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_uint8_ssa(a uint8) uint8 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_uint8_1_ssa(a uint8) uint8 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_uint8_ssa(a uint8) uint8 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_uint8_255_ssa(a uint8) uint8 {
+ return a * 255
+}
+
+//go:noinline
+func mul_255_uint8_ssa(a uint8) uint8 {
+ return 255 * a
+}
+
+//go:noinline
+func lsh_uint8_0_ssa(a uint8) uint8 {
+ return a << 0
+}
+
+//go:noinline
+func lsh_0_uint8_ssa(a uint8) uint8 {
+ return 0 << a
+}
+
+//go:noinline
+func lsh_uint8_1_ssa(a uint8) uint8 {
+ return a << 1
+}
+
+//go:noinline
+func lsh_1_uint8_ssa(a uint8) uint8 {
+ return 1 << a
+}
+
+//go:noinline
+func lsh_uint8_255_ssa(a uint8) uint8 {
+ return a << 255
+}
+
+//go:noinline
+func lsh_255_uint8_ssa(a uint8) uint8 {
+ return 255 << a
+}
+
+//go:noinline
+func rsh_uint8_0_ssa(a uint8) uint8 {
+ return a >> 0
+}
+
+//go:noinline
+func rsh_0_uint8_ssa(a uint8) uint8 {
+ return 0 >> a
+}
+
+//go:noinline
+func rsh_uint8_1_ssa(a uint8) uint8 {
+ return a >> 1
+}
+
+//go:noinline
+func rsh_1_uint8_ssa(a uint8) uint8 {
+ return 1 >> a
+}
+
+//go:noinline
+func rsh_uint8_255_ssa(a uint8) uint8 {
+ return a >> 255
+}
+
+//go:noinline
+func rsh_255_uint8_ssa(a uint8) uint8 {
+ return 255 >> a
+}
+
+//go:noinline
+func add_int8_Neg128_ssa(a int8) int8 {
+ return a + -128
+}
+
+//go:noinline
+func add_Neg128_int8_ssa(a int8) int8 {
+ return -128 + a
+}
+
+//go:noinline
+func add_int8_Neg127_ssa(a int8) int8 {
+ return a + -127
+}
+
+//go:noinline
+func add_Neg127_int8_ssa(a int8) int8 {
+ return -127 + a
+}
+
+//go:noinline
+func add_int8_Neg1_ssa(a int8) int8 {
+ return a + -1
+}
+
+//go:noinline
+func add_Neg1_int8_ssa(a int8) int8 {
+ return -1 + a
+}
+
+//go:noinline
+func add_int8_0_ssa(a int8) int8 {
+ return a + 0
+}
+
+//go:noinline
+func add_0_int8_ssa(a int8) int8 {
+ return 0 + a
+}
+
+//go:noinline
+func add_int8_1_ssa(a int8) int8 {
+ return a + 1
+}
+
+//go:noinline
+func add_1_int8_ssa(a int8) int8 {
+ return 1 + a
+}
+
+//go:noinline
+func add_int8_126_ssa(a int8) int8 {
+ return a + 126
+}
+
+//go:noinline
+func add_126_int8_ssa(a int8) int8 {
+ return 126 + a
+}
+
+//go:noinline
+func add_int8_127_ssa(a int8) int8 {
+ return a + 127
+}
+
+//go:noinline
+func add_127_int8_ssa(a int8) int8 {
+ return 127 + a
+}
+
+//go:noinline
+func sub_int8_Neg128_ssa(a int8) int8 {
+ return a - -128
+}
+
+//go:noinline
+func sub_Neg128_int8_ssa(a int8) int8 {
+ return -128 - a
+}
+
+//go:noinline
+func sub_int8_Neg127_ssa(a int8) int8 {
+ return a - -127
+}
+
+//go:noinline
+func sub_Neg127_int8_ssa(a int8) int8 {
+ return -127 - a
+}
+
+//go:noinline
+func sub_int8_Neg1_ssa(a int8) int8 {
+ return a - -1
+}
+
+//go:noinline
+func sub_Neg1_int8_ssa(a int8) int8 {
+ return -1 - a
+}
+
+//go:noinline
+func sub_int8_0_ssa(a int8) int8 {
+ return a - 0
+}
+
+//go:noinline
+func sub_0_int8_ssa(a int8) int8 {
+ return 0 - a
+}
+
+//go:noinline
+func sub_int8_1_ssa(a int8) int8 {
+ return a - 1
+}
+
+//go:noinline
+func sub_1_int8_ssa(a int8) int8 {
+ return 1 - a
+}
+
+//go:noinline
+func sub_int8_126_ssa(a int8) int8 {
+ return a - 126
+}
+
+//go:noinline
+func sub_126_int8_ssa(a int8) int8 {
+ return 126 - a
+}
+
+//go:noinline
+func sub_int8_127_ssa(a int8) int8 {
+ return a - 127
+}
+
+//go:noinline
+func sub_127_int8_ssa(a int8) int8 {
+ return 127 - a
+}
+
+//go:noinline
+func div_int8_Neg128_ssa(a int8) int8 {
+ return a / -128
+}
+
+//go:noinline
+func div_Neg128_int8_ssa(a int8) int8 {
+ return -128 / a
+}
+
+//go:noinline
+func div_int8_Neg127_ssa(a int8) int8 {
+ return a / -127
+}
+
+//go:noinline
+func div_Neg127_int8_ssa(a int8) int8 {
+ return -127 / a
+}
+
+//go:noinline
+func div_int8_Neg1_ssa(a int8) int8 {
+ return a / -1
+}
+
+//go:noinline
+func div_Neg1_int8_ssa(a int8) int8 {
+ return -1 / a
+}
+
+//go:noinline
+func div_0_int8_ssa(a int8) int8 {
+ return 0 / a
+}
+
+//go:noinline
+func div_int8_1_ssa(a int8) int8 {
+ return a / 1
+}
+
+//go:noinline
+func div_1_int8_ssa(a int8) int8 {
+ return 1 / a
+}
+
+//go:noinline
+func div_int8_126_ssa(a int8) int8 {
+ return a / 126
+}
+
+//go:noinline
+func div_126_int8_ssa(a int8) int8 {
+ return 126 / a
+}
+
+//go:noinline
+func div_int8_127_ssa(a int8) int8 {
+ return a / 127
+}
+
+//go:noinline
+func div_127_int8_ssa(a int8) int8 {
+ return 127 / a
+}
+
+//go:noinline
+func mul_int8_Neg128_ssa(a int8) int8 {
+ return a * -128
+}
+
+//go:noinline
+func mul_Neg128_int8_ssa(a int8) int8 {
+ return -128 * a
+}
+
+//go:noinline
+func mul_int8_Neg127_ssa(a int8) int8 {
+ return a * -127
+}
+
+//go:noinline
+func mul_Neg127_int8_ssa(a int8) int8 {
+ return -127 * a
+}
+
+//go:noinline
+func mul_int8_Neg1_ssa(a int8) int8 {
+ return a * -1
+}
+
+//go:noinline
+func mul_Neg1_int8_ssa(a int8) int8 {
+ return -1 * a
+}
+
+//go:noinline
+func mul_int8_0_ssa(a int8) int8 {
+ return a * 0
+}
+
+//go:noinline
+func mul_0_int8_ssa(a int8) int8 {
+ return 0 * a
+}
+
+//go:noinline
+func mul_int8_1_ssa(a int8) int8 {
+ return a * 1
+}
+
+//go:noinline
+func mul_1_int8_ssa(a int8) int8 {
+ return 1 * a
+}
+
+//go:noinline
+func mul_int8_126_ssa(a int8) int8 {
+ return a * 126
+}
+
+//go:noinline
+func mul_126_int8_ssa(a int8) int8 {
+ return 126 * a
+}
+
+//go:noinline
+func mul_int8_127_ssa(a int8) int8 {
+ return a * 127
+}
+
+//go:noinline
+func mul_127_int8_ssa(a int8) int8 {
+ return 127 * a
+}
+
+var failed bool
+
+func main() {
+
+ if got := add_0_uint64_ssa(0); got != 0 {
+ fmt.Printf("add_uint64 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_0_ssa(0); got != 0 {
+ fmt.Printf("add_uint64 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint64_ssa(1); got != 1 {
+ fmt.Printf("add_uint64 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_0_ssa(1); got != 1 {
+ fmt.Printf("add_uint64 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint64_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("add_uint64 0+4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("add_uint64 4294967296+0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint64_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("add_uint64 0+18446744073709551615 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("add_uint64 18446744073709551615+0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint64_ssa(0); got != 1 {
+ fmt.Printf("add_uint64 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_1_ssa(0); got != 1 {
+ fmt.Printf("add_uint64 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint64_ssa(1); got != 2 {
+ fmt.Printf("add_uint64 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_1_ssa(1); got != 2 {
+ fmt.Printf("add_uint64 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint64_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("add_uint64 1+4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_1_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("add_uint64 4294967296+1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("add_uint64 1+18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_1_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("add_uint64 18446744073709551615+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_uint64_ssa(0); got != 4294967296 {
+ fmt.Printf("add_uint64 4294967296+0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_4294967296_ssa(0); got != 4294967296 {
+ fmt.Printf("add_uint64 0+4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_uint64_ssa(1); got != 4294967297 {
+ fmt.Printf("add_uint64 4294967296+1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_4294967296_ssa(1); got != 4294967297 {
+ fmt.Printf("add_uint64 1+4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_uint64_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("add_uint64 4294967296+4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_4294967296_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("add_uint64 4294967296+4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_uint64_ssa(18446744073709551615); got != 4294967295 {
+ fmt.Printf("add_uint64 4294967296+18446744073709551615 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_4294967296_ssa(18446744073709551615); got != 4294967295 {
+ fmt.Printf("add_uint64 18446744073709551615+4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("add_uint64 18446744073709551615+0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_18446744073709551615_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("add_uint64 0+18446744073709551615 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := add_18446744073709551615_uint64_ssa(1); got != 0 {
+ fmt.Printf("add_uint64 18446744073709551615+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_18446744073709551615_ssa(1); got != 0 {
+ fmt.Printf("add_uint64 1+18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_18446744073709551615_uint64_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("add_uint64 18446744073709551615+4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_18446744073709551615_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("add_uint64 4294967296+18446744073709551615 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_18446744073709551615_uint64_ssa(18446744073709551615); got != 18446744073709551614 {
+ fmt.Printf("add_uint64 18446744073709551615+18446744073709551615 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := add_uint64_18446744073709551615_ssa(18446744073709551615); got != 18446744073709551614 {
+ fmt.Printf("add_uint64 18446744073709551615+18446744073709551615 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint64_ssa(0); got != 0 {
+ fmt.Printf("sub_uint64 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_0_ssa(0); got != 0 {
+ fmt.Printf("sub_uint64 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint64_ssa(1); got != 18446744073709551615 {
+ fmt.Printf("sub_uint64 0-1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_0_ssa(1); got != 1 {
+ fmt.Printf("sub_uint64 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint64_ssa(4294967296); got != 18446744069414584320 {
+ fmt.Printf("sub_uint64 0-4294967296 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("sub_uint64 4294967296-0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint64_ssa(18446744073709551615); got != 1 {
+ fmt.Printf("sub_uint64 0-18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("sub_uint64 18446744073709551615-0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint64_ssa(0); got != 1 {
+ fmt.Printf("sub_uint64 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_1_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("sub_uint64 0-1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint64_ssa(1); got != 0 {
+ fmt.Printf("sub_uint64 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_1_ssa(1); got != 0 {
+ fmt.Printf("sub_uint64 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint64_ssa(4294967296); got != 18446744069414584321 {
+ fmt.Printf("sub_uint64 1-4294967296 = %d, wanted 18446744069414584321\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_1_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("sub_uint64 4294967296-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint64_ssa(18446744073709551615); got != 2 {
+ fmt.Printf("sub_uint64 1-18446744073709551615 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_1_ssa(18446744073709551615); got != 18446744073709551614 {
+ fmt.Printf("sub_uint64 18446744073709551615-1 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_uint64_ssa(0); got != 4294967296 {
+ fmt.Printf("sub_uint64 4294967296-0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_4294967296_ssa(0); got != 18446744069414584320 {
+ fmt.Printf("sub_uint64 0-4294967296 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_uint64_ssa(1); got != 4294967295 {
+ fmt.Printf("sub_uint64 4294967296-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_4294967296_ssa(1); got != 18446744069414584321 {
+ fmt.Printf("sub_uint64 1-4294967296 = %d, wanted 18446744069414584321\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("sub_uint64 4294967296-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("sub_uint64 4294967296-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_uint64_ssa(18446744073709551615); got != 4294967297 {
+ fmt.Printf("sub_uint64 4294967296-18446744073709551615 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_4294967296_ssa(18446744073709551615); got != 18446744069414584319 {
+ fmt.Printf("sub_uint64 18446744073709551615-4294967296 = %d, wanted 18446744069414584319\n", got)
+ failed = true
+ }
+
+ if got := sub_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("sub_uint64 18446744073709551615-0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_18446744073709551615_ssa(0); got != 1 {
+ fmt.Printf("sub_uint64 0-18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_18446744073709551615_uint64_ssa(1); got != 18446744073709551614 {
+ fmt.Printf("sub_uint64 18446744073709551615-1 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_18446744073709551615_ssa(1); got != 2 {
+ fmt.Printf("sub_uint64 1-18446744073709551615 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_18446744073709551615_uint64_ssa(4294967296); got != 18446744069414584319 {
+ fmt.Printf("sub_uint64 18446744073709551615-4294967296 = %d, wanted 18446744069414584319\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_18446744073709551615_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("sub_uint64 4294967296-18446744073709551615 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("sub_uint64 18446744073709551615-18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint64_18446744073709551615_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("sub_uint64 18446744073709551615-18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint64_ssa(1); got != 0 {
+ fmt.Printf("div_uint64 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("div_uint64 0/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("div_uint64 0/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_1_ssa(0); got != 0 {
+ fmt.Printf("div_uint64 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint64_ssa(1); got != 1 {
+ fmt.Printf("div_uint64 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_1_ssa(1); got != 1 {
+ fmt.Printf("div_uint64 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("div_uint64 1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_1_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("div_uint64 4294967296/1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("div_uint64 1/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_1_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("div_uint64 18446744073709551615/1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("div_uint64 0/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_uint64_ssa(1); got != 4294967296 {
+ fmt.Printf("div_uint64 4294967296/1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_4294967296_ssa(1); got != 0 {
+ fmt.Printf("div_uint64 1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_uint64_ssa(4294967296); got != 1 {
+ fmt.Printf("div_uint64 4294967296/4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_4294967296_ssa(4294967296); got != 1 {
+ fmt.Printf("div_uint64 4294967296/4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("div_uint64 4294967296/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_4294967296_ssa(18446744073709551615); got != 4294967295 {
+ fmt.Printf("div_uint64 18446744073709551615/4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_18446744073709551615_ssa(0); got != 0 {
+ fmt.Printf("div_uint64 0/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_18446744073709551615_uint64_ssa(1); got != 18446744073709551615 {
+ fmt.Printf("div_uint64 18446744073709551615/1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_18446744073709551615_ssa(1); got != 0 {
+ fmt.Printf("div_uint64 1/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_18446744073709551615_uint64_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("div_uint64 18446744073709551615/4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_18446744073709551615_ssa(4294967296); got != 0 {
+ fmt.Printf("div_uint64 4294967296/18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_18446744073709551615_uint64_ssa(18446744073709551615); got != 1 {
+ fmt.Printf("div_uint64 18446744073709551615/18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint64_18446744073709551615_ssa(18446744073709551615); got != 1 {
+ fmt.Printf("div_uint64 18446744073709551615/18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint64_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_0_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint64_ssa(1); got != 0 {
+ fmt.Printf("mul_uint64 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_0_ssa(1); got != 0 {
+ fmt.Printf("mul_uint64 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_uint64 0*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_0_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_uint64 4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("mul_uint64 0*18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_0_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("mul_uint64 18446744073709551615*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint64_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_1_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint64_ssa(1); got != 1 {
+ fmt.Printf("mul_uint64 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_1_ssa(1); got != 1 {
+ fmt.Printf("mul_uint64 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint64_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_uint64 1*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_1_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_uint64 4294967296*1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint64_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("mul_uint64 1*18446744073709551615 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_1_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("mul_uint64 18446744073709551615*1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_uint64_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 0*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_uint64_ssa(1); got != 4294967296 {
+ fmt.Printf("mul_uint64 4294967296*1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_4294967296_ssa(1); got != 4294967296 {
+ fmt.Printf("mul_uint64 1*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_uint64 4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_uint64 4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_uint64_ssa(18446744073709551615); got != 18446744069414584320 {
+ fmt.Printf("mul_uint64 4294967296*18446744073709551615 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_4294967296_ssa(18446744073709551615); got != 18446744069414584320 {
+ fmt.Printf("mul_uint64 18446744073709551615*4294967296 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := mul_18446744073709551615_uint64_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 18446744073709551615*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_18446744073709551615_ssa(0); got != 0 {
+ fmt.Printf("mul_uint64 0*18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_18446744073709551615_uint64_ssa(1); got != 18446744073709551615 {
+ fmt.Printf("mul_uint64 18446744073709551615*1 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_18446744073709551615_ssa(1); got != 18446744073709551615 {
+ fmt.Printf("mul_uint64 1*18446744073709551615 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := mul_18446744073709551615_uint64_ssa(4294967296); got != 18446744069414584320 {
+ fmt.Printf("mul_uint64 18446744073709551615*4294967296 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_18446744073709551615_ssa(4294967296); got != 18446744069414584320 {
+ fmt.Printf("mul_uint64 4294967296*18446744073709551615 = %d, wanted 18446744069414584320\n", got)
+ failed = true
+ }
+
+ if got := mul_18446744073709551615_uint64_ssa(18446744073709551615); got != 1 {
+ fmt.Printf("mul_uint64 18446744073709551615*18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint64_18446744073709551615_ssa(18446744073709551615); got != 1 {
+ fmt.Printf("mul_uint64 18446744073709551615*18446744073709551615 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint64_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint64 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_0_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint64 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint64_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint64 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_0_ssa(1); got != 1 {
+ fmt.Printf("lsh_uint64 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 0<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("lsh_uint64 4294967296<<0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 0<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint64_ssa(0); got != 1 {
+ fmt.Printf("lsh_uint64 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_1_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint64 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint64_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint64 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_1_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint64 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 1<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_1_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("lsh_uint64 4294967296<<1 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 1<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_1_ssa(18446744073709551615); got != 18446744073709551614 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<1 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967296_uint64_ssa(0); got != 4294967296 {
+ fmt.Printf("lsh_uint64 4294967296<<0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint64 0<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967296_uint64_ssa(1); got != 8589934592 {
+ fmt.Printf("lsh_uint64 4294967296<<1 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_4294967296_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint64 1<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967296_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 4294967296<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 4294967296<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967296_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 4294967296<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_4294967296_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_18446744073709551615_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint64 0<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_18446744073709551615_uint64_ssa(1); got != 18446744073709551614 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<1 = %d, wanted 18446744073709551614\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_18446744073709551615_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint64 1<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_18446744073709551615_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_18446744073709551615_ssa(4294967296); got != 0 {
+ fmt.Printf("lsh_uint64 4294967296<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint64_18446744073709551615_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("lsh_uint64 18446744073709551615<<18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint64_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint64 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_0_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint64 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint64_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint64 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_0_ssa(1); got != 1 {
+ fmt.Printf("rsh_uint64 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 0>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("rsh_uint64 4294967296>>0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 0>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint64_ssa(0); got != 1 {
+ fmt.Printf("rsh_uint64 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_1_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint64 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint64_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint64 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_1_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint64 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 1>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_1_ssa(4294967296); got != 2147483648 {
+ fmt.Printf("rsh_uint64 4294967296>>1 = %d, wanted 2147483648\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 1>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_1_ssa(18446744073709551615); got != 9223372036854775807 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967296_uint64_ssa(0); got != 4294967296 {
+ fmt.Printf("rsh_uint64 4294967296>>0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint64 0>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967296_uint64_ssa(1); got != 2147483648 {
+ fmt.Printf("rsh_uint64 4294967296>>1 = %d, wanted 2147483648\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_4294967296_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint64 1>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967296_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 4294967296>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 4294967296>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967296_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 4294967296>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_4294967296_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>0 = %d, wanted 18446744073709551615\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_18446744073709551615_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint64 0>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_18446744073709551615_uint64_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_18446744073709551615_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint64 1>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_18446744073709551615_uint64_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_18446744073709551615_ssa(4294967296); got != 0 {
+ fmt.Printf("rsh_uint64 4294967296>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint64_18446744073709551615_ssa(18446744073709551615); got != 0 {
+ fmt.Printf("rsh_uint64 18446744073709551615>>18446744073709551615 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("add_int64 -9223372036854775808+-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("add_int64 -9223372036854775808+-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("add_int64 -9223372036854775808+-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("add_int64 -9223372036854775807+-9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(-4294967296); got != 9223372032559808512 {
+ fmt.Printf("add_int64 -9223372036854775808+-4294967296 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(-4294967296); got != 9223372032559808512 {
+ fmt.Printf("add_int64 -4294967296+-9223372036854775808 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775808+-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("add_int64 -1+-9223372036854775808 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(0); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -9223372036854775808+0 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(0); got != -9223372036854775808 {
+ fmt.Printf("add_int64 0+-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775808+1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("add_int64 1+-9223372036854775808 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(4294967296); got != -9223372032559808512 {
+ fmt.Printf("add_int64 -9223372036854775808+4294967296 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(4294967296); got != -9223372032559808512 {
+ fmt.Printf("add_int64 4294967296+-9223372036854775808 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(9223372036854775806); got != -2 {
+ fmt.Printf("add_int64 -9223372036854775808+9223372036854775806 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(9223372036854775806); got != -2 {
+ fmt.Printf("add_int64 9223372036854775806+-9223372036854775808 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775808_int64_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("add_int64 -9223372036854775808+9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775808_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("add_int64 9223372036854775807+-9223372036854775808 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("add_int64 -9223372036854775807+-9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("add_int64 -9223372036854775808+-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(-9223372036854775807); got != 2 {
+ fmt.Printf("add_int64 -9223372036854775807+-9223372036854775807 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 2 {
+ fmt.Printf("add_int64 -9223372036854775807+-9223372036854775807 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(-4294967296); got != 9223372032559808513 {
+ fmt.Printf("add_int64 -9223372036854775807+-4294967296 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(-4294967296); got != 9223372032559808513 {
+ fmt.Printf("add_int64 -4294967296+-9223372036854775807 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -9223372036854775807+-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -1+-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(0); got != -9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775807+0 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(0); got != -9223372036854775807 {
+ fmt.Printf("add_int64 0+-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775806 {
+ fmt.Printf("add_int64 -9223372036854775807+1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(1); got != -9223372036854775806 {
+ fmt.Printf("add_int64 1+-9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(4294967296); got != -9223372032559808511 {
+ fmt.Printf("add_int64 -9223372036854775807+4294967296 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(4294967296); got != -9223372032559808511 {
+ fmt.Printf("add_int64 4294967296+-9223372036854775807 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(9223372036854775806); got != -1 {
+ fmt.Printf("add_int64 -9223372036854775807+9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(9223372036854775806); got != -1 {
+ fmt.Printf("add_int64 9223372036854775806+-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg9223372036854775807_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("add_int64 -9223372036854775807+9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg9223372036854775807_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("add_int64 9223372036854775807+-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(-9223372036854775808); got != 9223372032559808512 {
+ fmt.Printf("add_int64 -4294967296+-9223372036854775808 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(-9223372036854775808); got != 9223372032559808512 {
+ fmt.Printf("add_int64 -9223372036854775808+-4294967296 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(-9223372036854775807); got != 9223372032559808513 {
+ fmt.Printf("add_int64 -4294967296+-9223372036854775807 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(-9223372036854775807); got != 9223372032559808513 {
+ fmt.Printf("add_int64 -9223372036854775807+-4294967296 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(-4294967296); got != -8589934592 {
+ fmt.Printf("add_int64 -4294967296+-4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(-4294967296); got != -8589934592 {
+ fmt.Printf("add_int64 -4294967296+-4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(-1); got != -4294967297 {
+ fmt.Printf("add_int64 -4294967296+-1 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(-1); got != -4294967297 {
+ fmt.Printf("add_int64 -1+-4294967296 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(0); got != -4294967296 {
+ fmt.Printf("add_int64 -4294967296+0 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(0); got != -4294967296 {
+ fmt.Printf("add_int64 0+-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(1); got != -4294967295 {
+ fmt.Printf("add_int64 -4294967296+1 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(1); got != -4294967295 {
+ fmt.Printf("add_int64 1+-4294967296 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("add_int64 -4294967296+4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("add_int64 4294967296+-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(9223372036854775806); got != 9223372032559808510 {
+ fmt.Printf("add_int64 -4294967296+9223372036854775806 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(9223372036854775806); got != 9223372032559808510 {
+ fmt.Printf("add_int64 9223372036854775806+-4294967296 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := add_Neg4294967296_int64_ssa(9223372036854775807); got != 9223372032559808511 {
+ fmt.Printf("add_int64 -4294967296+9223372036854775807 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg4294967296_ssa(9223372036854775807); got != 9223372032559808511 {
+ fmt.Printf("add_int64 9223372036854775807+-4294967296 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(-9223372036854775808); got != 9223372036854775807 {
+ fmt.Printf("add_int64 -1+-9223372036854775808 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(-9223372036854775808); got != 9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775808+-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -1+-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -9223372036854775807+-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(-4294967296); got != -4294967297 {
+ fmt.Printf("add_int64 -1+-4294967296 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(-4294967296); got != -4294967297 {
+ fmt.Printf("add_int64 -4294967296+-1 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(-1); got != -2 {
+ fmt.Printf("add_int64 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(-1); got != -2 {
+ fmt.Printf("add_int64 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(0); got != -1 {
+ fmt.Printf("add_int64 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(0); got != -1 {
+ fmt.Printf("add_int64 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(1); got != 0 {
+ fmt.Printf("add_int64 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(1); got != 0 {
+ fmt.Printf("add_int64 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("add_int64 -1+4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("add_int64 4294967296+-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(9223372036854775806); got != 9223372036854775805 {
+ fmt.Printf("add_int64 -1+9223372036854775806 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(9223372036854775806); got != 9223372036854775805 {
+ fmt.Printf("add_int64 9223372036854775806+-1 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int64_ssa(9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("add_int64 -1+9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_Neg1_ssa(9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("add_int64 9223372036854775807+-1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("add_int64 0+-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("add_int64 -9223372036854775808+0 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("add_int64 0+-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775807+0 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("add_int64 0+-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("add_int64 -4294967296+0 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(-1); got != -1 {
+ fmt.Printf("add_int64 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(-1); got != -1 {
+ fmt.Printf("add_int64 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(0); got != 0 {
+ fmt.Printf("add_int64 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(0); got != 0 {
+ fmt.Printf("add_int64 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(1); got != 1 {
+ fmt.Printf("add_int64 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(1); got != 1 {
+ fmt.Printf("add_int64 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("add_int64 0+4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("add_int64 4294967296+0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("add_int64 0+9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("add_int64 9223372036854775806+0 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_0_int64_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("add_int64 0+9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_0_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("add_int64 9223372036854775807+0 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(-9223372036854775808); got != -9223372036854775807 {
+ fmt.Printf("add_int64 1+-9223372036854775808 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(-9223372036854775808); got != -9223372036854775807 {
+ fmt.Printf("add_int64 -9223372036854775808+1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(-9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("add_int64 1+-9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(-9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("add_int64 -9223372036854775807+1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(-4294967296); got != -4294967295 {
+ fmt.Printf("add_int64 1+-4294967296 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(-4294967296); got != -4294967295 {
+ fmt.Printf("add_int64 -4294967296+1 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(-1); got != 0 {
+ fmt.Printf("add_int64 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(-1); got != 0 {
+ fmt.Printf("add_int64 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(0); got != 1 {
+ fmt.Printf("add_int64 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(0); got != 1 {
+ fmt.Printf("add_int64 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(1); got != 2 {
+ fmt.Printf("add_int64 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(1); got != 2 {
+ fmt.Printf("add_int64 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("add_int64 1+4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("add_int64 4294967296+1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(9223372036854775806); got != 9223372036854775807 {
+ fmt.Printf("add_int64 1+9223372036854775806 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(9223372036854775806); got != 9223372036854775807 {
+ fmt.Printf("add_int64 9223372036854775806+1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_1_int64_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("add_int64 1+9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_1_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("add_int64 9223372036854775807+1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(-9223372036854775808); got != -9223372032559808512 {
+ fmt.Printf("add_int64 4294967296+-9223372036854775808 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(-9223372036854775808); got != -9223372032559808512 {
+ fmt.Printf("add_int64 -9223372036854775808+4294967296 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(-9223372036854775807); got != -9223372032559808511 {
+ fmt.Printf("add_int64 4294967296+-9223372036854775807 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(-9223372036854775807); got != -9223372032559808511 {
+ fmt.Printf("add_int64 -9223372036854775807+4294967296 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("add_int64 4294967296+-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(-4294967296); got != 0 {
+ fmt.Printf("add_int64 -4294967296+4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(-1); got != 4294967295 {
+ fmt.Printf("add_int64 4294967296+-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(-1); got != 4294967295 {
+ fmt.Printf("add_int64 -1+4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(0); got != 4294967296 {
+ fmt.Printf("add_int64 4294967296+0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(0); got != 4294967296 {
+ fmt.Printf("add_int64 0+4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(1); got != 4294967297 {
+ fmt.Printf("add_int64 4294967296+1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(1); got != 4294967297 {
+ fmt.Printf("add_int64 1+4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("add_int64 4294967296+4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("add_int64 4294967296+4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(9223372036854775806); got != -9223372032559808514 {
+ fmt.Printf("add_int64 4294967296+9223372036854775806 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(9223372036854775806); got != -9223372032559808514 {
+ fmt.Printf("add_int64 9223372036854775806+4294967296 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := add_4294967296_int64_ssa(9223372036854775807); got != -9223372032559808513 {
+ fmt.Printf("add_int64 4294967296+9223372036854775807 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_int64_4294967296_ssa(9223372036854775807); got != -9223372032559808513 {
+ fmt.Printf("add_int64 9223372036854775807+4294967296 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(-9223372036854775808); got != -2 {
+ fmt.Printf("add_int64 9223372036854775806+-9223372036854775808 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(-9223372036854775808); got != -2 {
+ fmt.Printf("add_int64 -9223372036854775808+9223372036854775806 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("add_int64 9223372036854775806+-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("add_int64 -9223372036854775807+9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(-4294967296); got != 9223372032559808510 {
+ fmt.Printf("add_int64 9223372036854775806+-4294967296 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(-4294967296); got != 9223372032559808510 {
+ fmt.Printf("add_int64 -4294967296+9223372036854775806 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(-1); got != 9223372036854775805 {
+ fmt.Printf("add_int64 9223372036854775806+-1 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(-1); got != 9223372036854775805 {
+ fmt.Printf("add_int64 -1+9223372036854775806 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(0); got != 9223372036854775806 {
+ fmt.Printf("add_int64 9223372036854775806+0 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(0); got != 9223372036854775806 {
+ fmt.Printf("add_int64 0+9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("add_int64 9223372036854775806+1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("add_int64 1+9223372036854775806 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(4294967296); got != -9223372032559808514 {
+ fmt.Printf("add_int64 9223372036854775806+4294967296 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(4294967296); got != -9223372032559808514 {
+ fmt.Printf("add_int64 4294967296+9223372036854775806 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(9223372036854775806); got != -4 {
+ fmt.Printf("add_int64 9223372036854775806+9223372036854775806 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(9223372036854775806); got != -4 {
+ fmt.Printf("add_int64 9223372036854775806+9223372036854775806 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775806_int64_ssa(9223372036854775807); got != -3 {
+ fmt.Printf("add_int64 9223372036854775806+9223372036854775807 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775806_ssa(9223372036854775807); got != -3 {
+ fmt.Printf("add_int64 9223372036854775807+9223372036854775806 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("add_int64 9223372036854775807+-9223372036854775808 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("add_int64 -9223372036854775808+9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("add_int64 9223372036854775807+-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("add_int64 -9223372036854775807+9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(-4294967296); got != 9223372032559808511 {
+ fmt.Printf("add_int64 9223372036854775807+-4294967296 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(-4294967296); got != 9223372032559808511 {
+ fmt.Printf("add_int64 -4294967296+9223372036854775807 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(-1); got != 9223372036854775806 {
+ fmt.Printf("add_int64 9223372036854775807+-1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(-1); got != 9223372036854775806 {
+ fmt.Printf("add_int64 -1+9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(0); got != 9223372036854775807 {
+ fmt.Printf("add_int64 9223372036854775807+0 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(0); got != 9223372036854775807 {
+ fmt.Printf("add_int64 0+9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("add_int64 9223372036854775807+1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("add_int64 1+9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(4294967296); got != -9223372032559808513 {
+ fmt.Printf("add_int64 9223372036854775807+4294967296 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(4294967296); got != -9223372032559808513 {
+ fmt.Printf("add_int64 4294967296+9223372036854775807 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(9223372036854775806); got != -3 {
+ fmt.Printf("add_int64 9223372036854775807+9223372036854775806 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(9223372036854775806); got != -3 {
+ fmt.Printf("add_int64 9223372036854775806+9223372036854775807 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_9223372036854775807_int64_ssa(9223372036854775807); got != -2 {
+ fmt.Printf("add_int64 9223372036854775807+9223372036854775807 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int64_9223372036854775807_ssa(9223372036854775807); got != -2 {
+ fmt.Printf("add_int64 9223372036854775807+9223372036854775807 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("sub_int64 -9223372036854775808--9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("sub_int64 -9223372036854775808--9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("sub_int64 -9223372036854775808--9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("sub_int64 -9223372036854775807--9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(-4294967296); got != -9223372032559808512 {
+ fmt.Printf("sub_int64 -9223372036854775808--4294967296 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(-4294967296); got != 9223372032559808512 {
+ fmt.Printf("sub_int64 -4294967296--9223372036854775808 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(-1); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775808--1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 -1--9223372036854775808 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(0); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -9223372036854775808-0 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(0); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 0--9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775808-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 1--9223372036854775808 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(4294967296); got != 9223372032559808512 {
+ fmt.Printf("sub_int64 -9223372036854775808-4294967296 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(4294967296); got != -9223372032559808512 {
+ fmt.Printf("sub_int64 4294967296--9223372036854775808 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(9223372036854775806); got != 2 {
+ fmt.Printf("sub_int64 -9223372036854775808-9223372036854775806 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(9223372036854775806); got != -2 {
+ fmt.Printf("sub_int64 9223372036854775806--9223372036854775808 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775808_int64_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("sub_int64 -9223372036854775808-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775808_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("sub_int64 9223372036854775807--9223372036854775808 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("sub_int64 -9223372036854775807--9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("sub_int64 -9223372036854775808--9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("sub_int64 -9223372036854775807--9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("sub_int64 -9223372036854775807--9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(-4294967296); got != -9223372032559808511 {
+ fmt.Printf("sub_int64 -9223372036854775807--4294967296 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(-4294967296); got != 9223372032559808511 {
+ fmt.Printf("sub_int64 -4294967296--9223372036854775807 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(-1); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 -9223372036854775807--1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(-1); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 -1--9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(0); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775807-0 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(0); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 0--9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -9223372036854775807-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 1--9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(4294967296); got != 9223372032559808513 {
+ fmt.Printf("sub_int64 -9223372036854775807-4294967296 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(4294967296); got != -9223372032559808513 {
+ fmt.Printf("sub_int64 4294967296--9223372036854775807 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(9223372036854775806); got != 3 {
+ fmt.Printf("sub_int64 -9223372036854775807-9223372036854775806 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(9223372036854775806); got != -3 {
+ fmt.Printf("sub_int64 9223372036854775806--9223372036854775807 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg9223372036854775807_int64_ssa(9223372036854775807); got != 2 {
+ fmt.Printf("sub_int64 -9223372036854775807-9223372036854775807 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg9223372036854775807_ssa(9223372036854775807); got != -2 {
+ fmt.Printf("sub_int64 9223372036854775807--9223372036854775807 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(-9223372036854775808); got != 9223372032559808512 {
+ fmt.Printf("sub_int64 -4294967296--9223372036854775808 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(-9223372036854775808); got != -9223372032559808512 {
+ fmt.Printf("sub_int64 -9223372036854775808--4294967296 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(-9223372036854775807); got != 9223372032559808511 {
+ fmt.Printf("sub_int64 -4294967296--9223372036854775807 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(-9223372036854775807); got != -9223372032559808511 {
+ fmt.Printf("sub_int64 -9223372036854775807--4294967296 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("sub_int64 -4294967296--4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(-4294967296); got != 0 {
+ fmt.Printf("sub_int64 -4294967296--4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(-1); got != -4294967295 {
+ fmt.Printf("sub_int64 -4294967296--1 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(-1); got != 4294967295 {
+ fmt.Printf("sub_int64 -1--4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(0); got != -4294967296 {
+ fmt.Printf("sub_int64 -4294967296-0 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(0); got != 4294967296 {
+ fmt.Printf("sub_int64 0--4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(1); got != -4294967297 {
+ fmt.Printf("sub_int64 -4294967296-1 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(1); got != 4294967297 {
+ fmt.Printf("sub_int64 1--4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(4294967296); got != -8589934592 {
+ fmt.Printf("sub_int64 -4294967296-4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(4294967296); got != 8589934592 {
+ fmt.Printf("sub_int64 4294967296--4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(9223372036854775806); got != 9223372032559808514 {
+ fmt.Printf("sub_int64 -4294967296-9223372036854775806 = %d, wanted 9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(9223372036854775806); got != -9223372032559808514 {
+ fmt.Printf("sub_int64 9223372036854775806--4294967296 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg4294967296_int64_ssa(9223372036854775807); got != 9223372032559808513 {
+ fmt.Printf("sub_int64 -4294967296-9223372036854775807 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg4294967296_ssa(9223372036854775807); got != -9223372032559808513 {
+ fmt.Printf("sub_int64 9223372036854775807--4294967296 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(-9223372036854775808); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 -1--9223372036854775808 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(-9223372036854775808); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775808--1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(-9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 -1--9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(-9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 -9223372036854775807--1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(-4294967296); got != 4294967295 {
+ fmt.Printf("sub_int64 -1--4294967296 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(-4294967296); got != -4294967295 {
+ fmt.Printf("sub_int64 -4294967296--1 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(-1); got != 0 {
+ fmt.Printf("sub_int64 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(-1); got != 0 {
+ fmt.Printf("sub_int64 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(0); got != -1 {
+ fmt.Printf("sub_int64 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(0); got != 1 {
+ fmt.Printf("sub_int64 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(1); got != -2 {
+ fmt.Printf("sub_int64 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(1); got != 2 {
+ fmt.Printf("sub_int64 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(4294967296); got != -4294967297 {
+ fmt.Printf("sub_int64 -1-4294967296 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(4294967296); got != 4294967297 {
+ fmt.Printf("sub_int64 4294967296--1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(9223372036854775806); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -1-9223372036854775806 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(9223372036854775806); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 9223372036854775806--1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int64_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -1-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_Neg1_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 9223372036854775807--1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 0--9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -9223372036854775808-0 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(-9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 0--9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775807-0 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("sub_int64 0--4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("sub_int64 -4294967296-0 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(-1); got != 1 {
+ fmt.Printf("sub_int64 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(-1); got != -1 {
+ fmt.Printf("sub_int64 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(0); got != 0 {
+ fmt.Printf("sub_int64 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(0); got != 0 {
+ fmt.Printf("sub_int64 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(1); got != -1 {
+ fmt.Printf("sub_int64 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(1); got != 1 {
+ fmt.Printf("sub_int64 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("sub_int64 0-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("sub_int64 4294967296-0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 0-9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 9223372036854775806-0 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int64_ssa(9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 0-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_0_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 9223372036854775807-0 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(-9223372036854775808); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 1--9223372036854775808 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(-9223372036854775808); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 -9223372036854775808-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 1--9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -9223372036854775807-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(-4294967296); got != 4294967297 {
+ fmt.Printf("sub_int64 1--4294967296 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(-4294967296); got != -4294967297 {
+ fmt.Printf("sub_int64 -4294967296-1 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(-1); got != 2 {
+ fmt.Printf("sub_int64 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(-1); got != -2 {
+ fmt.Printf("sub_int64 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(0); got != 1 {
+ fmt.Printf("sub_int64 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(0); got != -1 {
+ fmt.Printf("sub_int64 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(1); got != 0 {
+ fmt.Printf("sub_int64 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(1); got != 0 {
+ fmt.Printf("sub_int64 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(4294967296); got != -4294967295 {
+ fmt.Printf("sub_int64 1-4294967296 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(4294967296); got != 4294967295 {
+ fmt.Printf("sub_int64 4294967296-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(9223372036854775806); got != -9223372036854775805 {
+ fmt.Printf("sub_int64 1-9223372036854775806 = %d, wanted -9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(9223372036854775806); got != 9223372036854775805 {
+ fmt.Printf("sub_int64 9223372036854775806-1 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int64_ssa(9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 1-9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_1_ssa(9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 9223372036854775807-1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(-9223372036854775808); got != -9223372032559808512 {
+ fmt.Printf("sub_int64 4294967296--9223372036854775808 = %d, wanted -9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(-9223372036854775808); got != 9223372032559808512 {
+ fmt.Printf("sub_int64 -9223372036854775808-4294967296 = %d, wanted 9223372032559808512\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(-9223372036854775807); got != -9223372032559808513 {
+ fmt.Printf("sub_int64 4294967296--9223372036854775807 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(-9223372036854775807); got != 9223372032559808513 {
+ fmt.Printf("sub_int64 -9223372036854775807-4294967296 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(-4294967296); got != 8589934592 {
+ fmt.Printf("sub_int64 4294967296--4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(-4294967296); got != -8589934592 {
+ fmt.Printf("sub_int64 -4294967296-4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(-1); got != 4294967297 {
+ fmt.Printf("sub_int64 4294967296--1 = %d, wanted 4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(-1); got != -4294967297 {
+ fmt.Printf("sub_int64 -1-4294967296 = %d, wanted -4294967297\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(0); got != 4294967296 {
+ fmt.Printf("sub_int64 4294967296-0 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(0); got != -4294967296 {
+ fmt.Printf("sub_int64 0-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(1); got != 4294967295 {
+ fmt.Printf("sub_int64 4294967296-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(1); got != -4294967295 {
+ fmt.Printf("sub_int64 1-4294967296 = %d, wanted -4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("sub_int64 4294967296-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("sub_int64 4294967296-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(9223372036854775806); got != -9223372032559808510 {
+ fmt.Printf("sub_int64 4294967296-9223372036854775806 = %d, wanted -9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(9223372036854775806); got != 9223372032559808510 {
+ fmt.Printf("sub_int64 9223372036854775806-4294967296 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967296_int64_ssa(9223372036854775807); got != -9223372032559808511 {
+ fmt.Printf("sub_int64 4294967296-9223372036854775807 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_4294967296_ssa(9223372036854775807); got != 9223372032559808511 {
+ fmt.Printf("sub_int64 9223372036854775807-4294967296 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(-9223372036854775808); got != -2 {
+ fmt.Printf("sub_int64 9223372036854775806--9223372036854775808 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(-9223372036854775808); got != 2 {
+ fmt.Printf("sub_int64 -9223372036854775808-9223372036854775806 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(-9223372036854775807); got != -3 {
+ fmt.Printf("sub_int64 9223372036854775806--9223372036854775807 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(-9223372036854775807); got != 3 {
+ fmt.Printf("sub_int64 -9223372036854775807-9223372036854775806 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(-4294967296); got != -9223372032559808514 {
+ fmt.Printf("sub_int64 9223372036854775806--4294967296 = %d, wanted -9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(-4294967296); got != 9223372032559808514 {
+ fmt.Printf("sub_int64 -4294967296-9223372036854775806 = %d, wanted 9223372032559808514\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 9223372036854775806--1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(-1); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 -1-9223372036854775806 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(0); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 9223372036854775806-0 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(0); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 0-9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(1); got != 9223372036854775805 {
+ fmt.Printf("sub_int64 9223372036854775806-1 = %d, wanted 9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(1); got != -9223372036854775805 {
+ fmt.Printf("sub_int64 1-9223372036854775806 = %d, wanted -9223372036854775805\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(4294967296); got != 9223372032559808510 {
+ fmt.Printf("sub_int64 9223372036854775806-4294967296 = %d, wanted 9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(4294967296); got != -9223372032559808510 {
+ fmt.Printf("sub_int64 4294967296-9223372036854775806 = %d, wanted -9223372032559808510\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("sub_int64 9223372036854775806-9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("sub_int64 9223372036854775806-9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775806_int64_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("sub_int64 9223372036854775806-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775806_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("sub_int64 9223372036854775807-9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("sub_int64 9223372036854775807--9223372036854775808 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("sub_int64 -9223372036854775808-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(-9223372036854775807); got != -2 {
+ fmt.Printf("sub_int64 9223372036854775807--9223372036854775807 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(-9223372036854775807); got != 2 {
+ fmt.Printf("sub_int64 -9223372036854775807-9223372036854775807 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(-4294967296); got != -9223372032559808513 {
+ fmt.Printf("sub_int64 9223372036854775807--4294967296 = %d, wanted -9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(-4294967296); got != 9223372032559808513 {
+ fmt.Printf("sub_int64 -4294967296-9223372036854775807 = %d, wanted 9223372032559808513\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 9223372036854775807--1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("sub_int64 -1-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(0); got != 9223372036854775807 {
+ fmt.Printf("sub_int64 9223372036854775807-0 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(0); got != -9223372036854775807 {
+ fmt.Printf("sub_int64 0-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(1); got != 9223372036854775806 {
+ fmt.Printf("sub_int64 9223372036854775807-1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(1); got != -9223372036854775806 {
+ fmt.Printf("sub_int64 1-9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(4294967296); got != 9223372032559808511 {
+ fmt.Printf("sub_int64 9223372036854775807-4294967296 = %d, wanted 9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(4294967296); got != -9223372032559808511 {
+ fmt.Printf("sub_int64 4294967296-9223372036854775807 = %d, wanted -9223372032559808511\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(9223372036854775806); got != 1 {
+ fmt.Printf("sub_int64 9223372036854775807-9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(9223372036854775806); got != -1 {
+ fmt.Printf("sub_int64 9223372036854775806-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_9223372036854775807_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("sub_int64 9223372036854775807-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int64_9223372036854775807_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("sub_int64 9223372036854775807-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775808/-9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775808/-9223372036854775808 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775808/-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 -9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(-4294967296); got != 2147483648 {
+ fmt.Printf("div_int64 -9223372036854775808/-4294967296 = %d, wanted 2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 -4294967296/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("div_int64 -9223372036854775808/-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("div_int64 -9223372036854775808/1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(4294967296); got != -2147483648 {
+ fmt.Printf("div_int64 -9223372036854775808/4294967296 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 4294967296/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(9223372036854775806); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775808/9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775808_int64_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775808/9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775808_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 -9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775808/-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775807/-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 -9223372036854775807/-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(-4294967296); got != 2147483647 {
+ fmt.Printf("div_int64 -9223372036854775807/-4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 -4294967296/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("div_int64 -9223372036854775807/-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("div_int64 -9223372036854775807/1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(4294967296); got != -2147483647 {
+ fmt.Printf("div_int64 -9223372036854775807/4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 4294967296/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(9223372036854775806); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775807/9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg9223372036854775807_int64_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775807/9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg9223372036854775807_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 9223372036854775807/-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 -4294967296/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(-9223372036854775808); got != 2147483648 {
+ fmt.Printf("div_int64 -9223372036854775808/-4294967296 = %d, wanted 2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 -4294967296/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(-9223372036854775807); got != 2147483647 {
+ fmt.Printf("div_int64 -9223372036854775807/-4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(-4294967296); got != 1 {
+ fmt.Printf("div_int64 -4294967296/-4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(-4294967296); got != 1 {
+ fmt.Printf("div_int64 -4294967296/-4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(-1); got != 4294967296 {
+ fmt.Printf("div_int64 -4294967296/-1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(1); got != -4294967296 {
+ fmt.Printf("div_int64 -4294967296/1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(4294967296); got != -1 {
+ fmt.Printf("div_int64 -4294967296/4294967296 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(4294967296); got != -1 {
+ fmt.Printf("div_int64 4294967296/-4294967296 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 -4294967296/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(9223372036854775806); got != -2147483647 {
+ fmt.Printf("div_int64 9223372036854775806/-4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_Neg4294967296_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 -4294967296/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg4294967296_ssa(9223372036854775807); got != -2147483647 {
+ fmt.Printf("div_int64 9223372036854775807/-4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 -1/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("div_int64 -9223372036854775808/-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 -1/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(-9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("div_int64 -9223372036854775807/-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 -1/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("div_int64 -4294967296/-1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(-1); got != 1 {
+ fmt.Printf("div_int64 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("div_int64 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(1); got != -1 {
+ fmt.Printf("div_int64 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(1); got != -1 {
+ fmt.Printf("div_int64 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 -1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("div_int64 4294967296/-1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 -1/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("div_int64 9223372036854775806/-1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 -1/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_Neg1_ssa(9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("div_int64 9223372036854775807/-1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 0/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 0/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 0/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(1); got != 0 {
+ fmt.Printf("div_int64 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 0/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 0/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 0/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 1/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("div_int64 -9223372036854775808/1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 1/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("div_int64 -9223372036854775807/1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 1/-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("div_int64 -4294967296/1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(-1); got != -1 {
+ fmt.Printf("div_int64 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(-1); got != -1 {
+ fmt.Printf("div_int64 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(1); got != 1 {
+ fmt.Printf("div_int64 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(1); got != 1 {
+ fmt.Printf("div_int64 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("div_int64 4294967296/1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 1/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("div_int64 9223372036854775806/1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := div_1_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 1/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_1_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("div_int64 9223372036854775807/1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 4294967296/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(-9223372036854775808); got != -2147483648 {
+ fmt.Printf("div_int64 -9223372036854775808/4294967296 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 4294967296/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(-9223372036854775807); got != -2147483647 {
+ fmt.Printf("div_int64 -9223372036854775807/4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(-4294967296); got != -1 {
+ fmt.Printf("div_int64 4294967296/-4294967296 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(-4294967296); got != -1 {
+ fmt.Printf("div_int64 -4294967296/4294967296 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(-1); got != -4294967296 {
+ fmt.Printf("div_int64 4294967296/-1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(1); got != 4294967296 {
+ fmt.Printf("div_int64 4294967296/1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(4294967296); got != 1 {
+ fmt.Printf("div_int64 4294967296/4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(4294967296); got != 1 {
+ fmt.Printf("div_int64 4294967296/4294967296 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 4294967296/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(9223372036854775806); got != 2147483647 {
+ fmt.Printf("div_int64 9223372036854775806/4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_4294967296_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 4294967296/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_4294967296_ssa(9223372036854775807); got != 2147483647 {
+ fmt.Printf("div_int64 9223372036854775807/4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775808/9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775807/9223372036854775806 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(-4294967296); got != -2147483647 {
+ fmt.Printf("div_int64 9223372036854775806/-4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 -4294967296/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(-1); got != -9223372036854775806 {
+ fmt.Printf("div_int64 9223372036854775806/-1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(1); got != 9223372036854775806 {
+ fmt.Printf("div_int64 9223372036854775806/1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(4294967296); got != 2147483647 {
+ fmt.Printf("div_int64 9223372036854775806/4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 4294967296/9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(9223372036854775806); got != 1 {
+ fmt.Printf("div_int64 9223372036854775806/9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(9223372036854775806); got != 1 {
+ fmt.Printf("div_int64 9223372036854775806/9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775806_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775806_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 9223372036854775807/9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("div_int64 9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(-9223372036854775808); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775808/9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 9223372036854775807/-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("div_int64 -9223372036854775807/9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(-4294967296); got != -2147483647 {
+ fmt.Printf("div_int64 9223372036854775807/-4294967296 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(-4294967296); got != 0 {
+ fmt.Printf("div_int64 -4294967296/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(-1); got != -9223372036854775807 {
+ fmt.Printf("div_int64 9223372036854775807/-1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(-1); got != 0 {
+ fmt.Printf("div_int64 -1/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(0); got != 0 {
+ fmt.Printf("div_int64 0/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("div_int64 9223372036854775807/1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(1); got != 0 {
+ fmt.Printf("div_int64 1/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(4294967296); got != 2147483647 {
+ fmt.Printf("div_int64 9223372036854775807/4294967296 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(4294967296); got != 0 {
+ fmt.Printf("div_int64 4294967296/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(9223372036854775806); got != 1 {
+ fmt.Printf("div_int64 9223372036854775807/9223372036854775806 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("div_int64 9223372036854775806/9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_9223372036854775807_int64_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 9223372036854775807/9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int64_9223372036854775807_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("div_int64 9223372036854775807/9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775807*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(-1); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -1*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(1); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 1*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775806*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775808_int64_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775808_ssa(9223372036854775807); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 9223372036854775807*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775807*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*-9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("mul_int64 -9223372036854775807*-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 1 {
+ fmt.Printf("mul_int64 -9223372036854775807*-9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 -9223372036854775807*-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 -4294967296*-9223372036854775807 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 -9223372036854775807*-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(-1); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 -1*-9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775807*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 -9223372036854775807*1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(1); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 1*-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 -9223372036854775807*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 4294967296*-9223372036854775807 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 -9223372036854775807*9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*-9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg9223372036854775807_int64_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("mul_int64 -9223372036854775807*9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg9223372036854775807_ssa(9223372036854775807); got != -1 {
+ fmt.Printf("mul_int64 9223372036854775807*-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(-9223372036854775807); got != -4294967296 {
+ fmt.Printf("mul_int64 -4294967296*-9223372036854775807 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(-9223372036854775807); got != -4294967296 {
+ fmt.Printf("mul_int64 -9223372036854775807*-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(-1); got != 4294967296 {
+ fmt.Printf("mul_int64 -4294967296*-1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(-1); got != 4294967296 {
+ fmt.Printf("mul_int64 -1*-4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(1); got != -4294967296 {
+ fmt.Printf("mul_int64 -4294967296*1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(1); got != -4294967296 {
+ fmt.Printf("mul_int64 1*-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(9223372036854775806); got != 8589934592 {
+ fmt.Printf("mul_int64 -4294967296*9223372036854775806 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(9223372036854775806); got != 8589934592 {
+ fmt.Printf("mul_int64 9223372036854775806*-4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg4294967296_int64_ssa(9223372036854775807); got != 4294967296 {
+ fmt.Printf("mul_int64 -4294967296*9223372036854775807 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg4294967296_ssa(9223372036854775807); got != 4294967296 {
+ fmt.Printf("mul_int64 9223372036854775807*-4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -1*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*-1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(-9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 -1*-9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(-9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 -9223372036854775807*-1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 -1*-4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 -4294967296*-1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(-1); got != 1 {
+ fmt.Printf("mul_int64 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("mul_int64 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(1); got != -1 {
+ fmt.Printf("mul_int64 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(1); got != -1 {
+ fmt.Printf("mul_int64 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 -1*4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 4294967296*-1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 -1*9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*-1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int64_ssa(9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 -1*9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_Neg1_ssa(9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 9223372036854775807*-1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 0*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("mul_int64 0*-9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(-9223372036854775807); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775807*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 0*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(-1); got != 0 {
+ fmt.Printf("mul_int64 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(-1); got != 0 {
+ fmt.Printf("mul_int64 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(1); got != 0 {
+ fmt.Printf("mul_int64 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(1); got != 0 {
+ fmt.Printf("mul_int64 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 0*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("mul_int64 0*9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(9223372036854775806); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775806*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int64_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("mul_int64 0*9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_0_ssa(9223372036854775807); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775807*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 1*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*1 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 1*-9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(-9223372036854775807); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 -9223372036854775807*1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 1*-4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(-4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 -4294967296*1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(-1); got != -1 {
+ fmt.Printf("mul_int64 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(-1); got != -1 {
+ fmt.Printf("mul_int64 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(1); got != 1 {
+ fmt.Printf("mul_int64 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(1); got != 1 {
+ fmt.Printf("mul_int64 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 1*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 4294967296*1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 1*9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(9223372036854775806); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int64_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 1*9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_1_ssa(9223372036854775807); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 9223372036854775807*1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 4294967296*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(-9223372036854775807); got != 4294967296 {
+ fmt.Printf("mul_int64 4294967296*-9223372036854775807 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(-9223372036854775807); got != 4294967296 {
+ fmt.Printf("mul_int64 -9223372036854775807*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*-4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(-4294967296); got != 0 {
+ fmt.Printf("mul_int64 -4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(-1); got != -4294967296 {
+ fmt.Printf("mul_int64 4294967296*-1 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(-1); got != -4294967296 {
+ fmt.Printf("mul_int64 -1*4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 4294967296*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(1); got != 4294967296 {
+ fmt.Printf("mul_int64 4294967296*1 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(1); got != 4294967296 {
+ fmt.Printf("mul_int64 1*4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(4294967296); got != 0 {
+ fmt.Printf("mul_int64 4294967296*4294967296 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(9223372036854775806); got != -8589934592 {
+ fmt.Printf("mul_int64 4294967296*9223372036854775806 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(9223372036854775806); got != -8589934592 {
+ fmt.Printf("mul_int64 9223372036854775806*4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967296_int64_ssa(9223372036854775807); got != -4294967296 {
+ fmt.Printf("mul_int64 4294967296*9223372036854775807 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_4294967296_ssa(9223372036854775807); got != -4294967296 {
+ fmt.Printf("mul_int64 9223372036854775807*4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775806*-9223372036854775808 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(-9223372036854775808); got != 0 {
+ fmt.Printf("mul_int64 -9223372036854775808*9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(-9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*-9223372036854775807 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(-9223372036854775807); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 -9223372036854775807*9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(-4294967296); got != 8589934592 {
+ fmt.Printf("mul_int64 9223372036854775806*-4294967296 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(-4294967296); got != 8589934592 {
+ fmt.Printf("mul_int64 -4294967296*9223372036854775806 = %d, wanted 8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(-1); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*-1 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(-1); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 -1*9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775806*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*9223372036854775806 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(1); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*1 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(1); got != 9223372036854775806 {
+ fmt.Printf("mul_int64 1*9223372036854775806 = %d, wanted 9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(4294967296); got != -8589934592 {
+ fmt.Printf("mul_int64 9223372036854775806*4294967296 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(4294967296); got != -8589934592 {
+ fmt.Printf("mul_int64 4294967296*9223372036854775806 = %d, wanted -8589934592\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(9223372036854775806); got != 4 {
+ fmt.Printf("mul_int64 9223372036854775806*9223372036854775806 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(9223372036854775806); got != 4 {
+ fmt.Printf("mul_int64 9223372036854775806*9223372036854775806 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775806_int64_ssa(9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775806_ssa(9223372036854775807); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775807*9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 9223372036854775807*-9223372036854775808 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(-9223372036854775808); got != -9223372036854775808 {
+ fmt.Printf("mul_int64 -9223372036854775808*9223372036854775807 = %d, wanted -9223372036854775808\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("mul_int64 9223372036854775807*-9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(-9223372036854775807); got != -1 {
+ fmt.Printf("mul_int64 -9223372036854775807*9223372036854775807 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 9223372036854775807*-4294967296 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(-4294967296); got != 4294967296 {
+ fmt.Printf("mul_int64 -4294967296*9223372036854775807 = %d, wanted 4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(-1); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 9223372036854775807*-1 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(-1); got != -9223372036854775807 {
+ fmt.Printf("mul_int64 -1*9223372036854775807 = %d, wanted -9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 9223372036854775807*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(0); got != 0 {
+ fmt.Printf("mul_int64 0*9223372036854775807 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 9223372036854775807*1 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(1); got != 9223372036854775807 {
+ fmt.Printf("mul_int64 1*9223372036854775807 = %d, wanted 9223372036854775807\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 9223372036854775807*4294967296 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(4294967296); got != -4294967296 {
+ fmt.Printf("mul_int64 4294967296*9223372036854775807 = %d, wanted -4294967296\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775807*9223372036854775806 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(9223372036854775806); got != -9223372036854775806 {
+ fmt.Printf("mul_int64 9223372036854775806*9223372036854775807 = %d, wanted -9223372036854775806\n", got)
+ failed = true
+ }
+
+ if got := mul_9223372036854775807_int64_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("mul_int64 9223372036854775807*9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int64_9223372036854775807_ssa(9223372036854775807); got != 1 {
+ fmt.Printf("mul_int64 9223372036854775807*9223372036854775807 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint32_ssa(0); got != 0 {
+ fmt.Printf("add_uint32 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_0_ssa(0); got != 0 {
+ fmt.Printf("add_uint32 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint32_ssa(1); got != 1 {
+ fmt.Printf("add_uint32 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_0_ssa(1); got != 1 {
+ fmt.Printf("add_uint32 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint32_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("add_uint32 0+4294967295 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_0_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("add_uint32 4294967295+0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint32_ssa(0); got != 1 {
+ fmt.Printf("add_uint32 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_1_ssa(0); got != 1 {
+ fmt.Printf("add_uint32 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint32_ssa(1); got != 2 {
+ fmt.Printf("add_uint32 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_1_ssa(1); got != 2 {
+ fmt.Printf("add_uint32 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("add_uint32 1+4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_1_ssa(4294967295); got != 0 {
+ fmt.Printf("add_uint32 4294967295+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_4294967295_uint32_ssa(0); got != 4294967295 {
+ fmt.Printf("add_uint32 4294967295+0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_4294967295_ssa(0); got != 4294967295 {
+ fmt.Printf("add_uint32 0+4294967295 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := add_4294967295_uint32_ssa(1); got != 0 {
+ fmt.Printf("add_uint32 4294967295+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_4294967295_ssa(1); got != 0 {
+ fmt.Printf("add_uint32 1+4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_4294967295_uint32_ssa(4294967295); got != 4294967294 {
+ fmt.Printf("add_uint32 4294967295+4294967295 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := add_uint32_4294967295_ssa(4294967295); got != 4294967294 {
+ fmt.Printf("add_uint32 4294967295+4294967295 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint32_ssa(0); got != 0 {
+ fmt.Printf("sub_uint32 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_0_ssa(0); got != 0 {
+ fmt.Printf("sub_uint32 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint32_ssa(1); got != 4294967295 {
+ fmt.Printf("sub_uint32 0-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_0_ssa(1); got != 1 {
+ fmt.Printf("sub_uint32 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint32_ssa(4294967295); got != 1 {
+ fmt.Printf("sub_uint32 0-4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_0_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("sub_uint32 4294967295-0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint32_ssa(0); got != 1 {
+ fmt.Printf("sub_uint32 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_1_ssa(0); got != 4294967295 {
+ fmt.Printf("sub_uint32 0-1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint32_ssa(1); got != 0 {
+ fmt.Printf("sub_uint32 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_1_ssa(1); got != 0 {
+ fmt.Printf("sub_uint32 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint32_ssa(4294967295); got != 2 {
+ fmt.Printf("sub_uint32 1-4294967295 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_1_ssa(4294967295); got != 4294967294 {
+ fmt.Printf("sub_uint32 4294967295-1 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967295_uint32_ssa(0); got != 4294967295 {
+ fmt.Printf("sub_uint32 4294967295-0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_4294967295_ssa(0); got != 1 {
+ fmt.Printf("sub_uint32 0-4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967295_uint32_ssa(1); got != 4294967294 {
+ fmt.Printf("sub_uint32 4294967295-1 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_4294967295_ssa(1); got != 2 {
+ fmt.Printf("sub_uint32 1-4294967295 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_4294967295_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("sub_uint32 4294967295-4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint32_4294967295_ssa(4294967295); got != 0 {
+ fmt.Printf("sub_uint32 4294967295-4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint32_ssa(1); got != 0 {
+ fmt.Printf("div_uint32 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("div_uint32 0/4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_1_ssa(0); got != 0 {
+ fmt.Printf("div_uint32 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint32_ssa(1); got != 1 {
+ fmt.Printf("div_uint32 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_1_ssa(1); got != 1 {
+ fmt.Printf("div_uint32 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("div_uint32 1/4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_1_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("div_uint32 4294967295/1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_4294967295_ssa(0); got != 0 {
+ fmt.Printf("div_uint32 0/4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967295_uint32_ssa(1); got != 4294967295 {
+ fmt.Printf("div_uint32 4294967295/1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_4294967295_ssa(1); got != 0 {
+ fmt.Printf("div_uint32 1/4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_4294967295_uint32_ssa(4294967295); got != 1 {
+ fmt.Printf("div_uint32 4294967295/4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint32_4294967295_ssa(4294967295); got != 1 {
+ fmt.Printf("div_uint32 4294967295/4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint32_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_0_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint32_ssa(1); got != 0 {
+ fmt.Printf("mul_uint32 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_0_ssa(1); got != 0 {
+ fmt.Printf("mul_uint32 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("mul_uint32 0*4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_0_ssa(4294967295); got != 0 {
+ fmt.Printf("mul_uint32 4294967295*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint32_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_1_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint32_ssa(1); got != 1 {
+ fmt.Printf("mul_uint32 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_1_ssa(1); got != 1 {
+ fmt.Printf("mul_uint32 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint32_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("mul_uint32 1*4294967295 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_1_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("mul_uint32 4294967295*1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967295_uint32_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 4294967295*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_4294967295_ssa(0); got != 0 {
+ fmt.Printf("mul_uint32 0*4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967295_uint32_ssa(1); got != 4294967295 {
+ fmt.Printf("mul_uint32 4294967295*1 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_4294967295_ssa(1); got != 4294967295 {
+ fmt.Printf("mul_uint32 1*4294967295 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := mul_4294967295_uint32_ssa(4294967295); got != 1 {
+ fmt.Printf("mul_uint32 4294967295*4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint32_4294967295_ssa(4294967295); got != 1 {
+ fmt.Printf("mul_uint32 4294967295*4294967295 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint32_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint32 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_0_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint32 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint32_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint32 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_0_ssa(1); got != 1 {
+ fmt.Printf("lsh_uint32 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("lsh_uint32 0<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_0_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("lsh_uint32 4294967295<<0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint32_ssa(0); got != 1 {
+ fmt.Printf("lsh_uint32 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_1_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint32 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint32_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint32 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_1_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint32 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("lsh_uint32 1<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_1_ssa(4294967295); got != 4294967294 {
+ fmt.Printf("lsh_uint32 4294967295<<1 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967295_uint32_ssa(0); got != 4294967295 {
+ fmt.Printf("lsh_uint32 4294967295<<0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_4294967295_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint32 0<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967295_uint32_ssa(1); got != 4294967294 {
+ fmt.Printf("lsh_uint32 4294967295<<1 = %d, wanted 4294967294\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_4294967295_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint32 1<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_4294967295_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("lsh_uint32 4294967295<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint32_4294967295_ssa(4294967295); got != 0 {
+ fmt.Printf("lsh_uint32 4294967295<<4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint32_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint32 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_0_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint32 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint32_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint32 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_0_ssa(1); got != 1 {
+ fmt.Printf("rsh_uint32 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("rsh_uint32 0>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_0_ssa(4294967295); got != 4294967295 {
+ fmt.Printf("rsh_uint32 4294967295>>0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint32_ssa(0); got != 1 {
+ fmt.Printf("rsh_uint32 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_1_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint32 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint32_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint32 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_1_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint32 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("rsh_uint32 1>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_1_ssa(4294967295); got != 2147483647 {
+ fmt.Printf("rsh_uint32 4294967295>>1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967295_uint32_ssa(0); got != 4294967295 {
+ fmt.Printf("rsh_uint32 4294967295>>0 = %d, wanted 4294967295\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_4294967295_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint32 0>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967295_uint32_ssa(1); got != 2147483647 {
+ fmt.Printf("rsh_uint32 4294967295>>1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_4294967295_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint32 1>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_4294967295_uint32_ssa(4294967295); got != 0 {
+ fmt.Printf("rsh_uint32 4294967295>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint32_4294967295_ssa(4294967295); got != 0 {
+ fmt.Printf("rsh_uint32 4294967295>>4294967295 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("add_int32 -2147483648+-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(-2147483648); got != 0 {
+ fmt.Printf("add_int32 -2147483648+-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(-2147483647); got != 1 {
+ fmt.Printf("add_int32 -2147483648+-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(-2147483647); got != 1 {
+ fmt.Printf("add_int32 -2147483647+-2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(-1); got != 2147483647 {
+ fmt.Printf("add_int32 -2147483648+-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(-1); got != 2147483647 {
+ fmt.Printf("add_int32 -1+-2147483648 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(0); got != -2147483648 {
+ fmt.Printf("add_int32 -2147483648+0 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(0); got != -2147483648 {
+ fmt.Printf("add_int32 0+-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(1); got != -2147483647 {
+ fmt.Printf("add_int32 -2147483648+1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(1); got != -2147483647 {
+ fmt.Printf("add_int32 1+-2147483648 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483648_int32_ssa(2147483647); got != -1 {
+ fmt.Printf("add_int32 -2147483648+2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483648_ssa(2147483647); got != -1 {
+ fmt.Printf("add_int32 2147483647+-2147483648 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(-2147483648); got != 1 {
+ fmt.Printf("add_int32 -2147483647+-2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(-2147483648); got != 1 {
+ fmt.Printf("add_int32 -2147483648+-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(-2147483647); got != 2 {
+ fmt.Printf("add_int32 -2147483647+-2147483647 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(-2147483647); got != 2 {
+ fmt.Printf("add_int32 -2147483647+-2147483647 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(-1); got != -2147483648 {
+ fmt.Printf("add_int32 -2147483647+-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(-1); got != -2147483648 {
+ fmt.Printf("add_int32 -1+-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(0); got != -2147483647 {
+ fmt.Printf("add_int32 -2147483647+0 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(0); got != -2147483647 {
+ fmt.Printf("add_int32 0+-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(1); got != -2147483646 {
+ fmt.Printf("add_int32 -2147483647+1 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(1); got != -2147483646 {
+ fmt.Printf("add_int32 1+-2147483647 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_Neg2147483647_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("add_int32 -2147483647+2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg2147483647_ssa(2147483647); got != 0 {
+ fmt.Printf("add_int32 2147483647+-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(-2147483648); got != 2147483647 {
+ fmt.Printf("add_int32 -1+-2147483648 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(-2147483648); got != 2147483647 {
+ fmt.Printf("add_int32 -2147483648+-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("add_int32 -1+-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("add_int32 -2147483647+-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(-1); got != -2 {
+ fmt.Printf("add_int32 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(-1); got != -2 {
+ fmt.Printf("add_int32 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(0); got != -1 {
+ fmt.Printf("add_int32 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(0); got != -1 {
+ fmt.Printf("add_int32 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(1); got != 0 {
+ fmt.Printf("add_int32 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(1); got != 0 {
+ fmt.Printf("add_int32 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int32_ssa(2147483647); got != 2147483646 {
+ fmt.Printf("add_int32 -1+2147483647 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_int32_Neg1_ssa(2147483647); got != 2147483646 {
+ fmt.Printf("add_int32 2147483647+-1 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("add_int32 0+-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("add_int32 -2147483648+0 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("add_int32 0+-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("add_int32 -2147483647+0 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(-1); got != -1 {
+ fmt.Printf("add_int32 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(-1); got != -1 {
+ fmt.Printf("add_int32 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(0); got != 0 {
+ fmt.Printf("add_int32 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(0); got != 0 {
+ fmt.Printf("add_int32 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(1); got != 1 {
+ fmt.Printf("add_int32 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(1); got != 1 {
+ fmt.Printf("add_int32 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int32_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("add_int32 0+2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_0_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("add_int32 2147483647+0 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(-2147483648); got != -2147483647 {
+ fmt.Printf("add_int32 1+-2147483648 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(-2147483648); got != -2147483647 {
+ fmt.Printf("add_int32 -2147483648+1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(-2147483647); got != -2147483646 {
+ fmt.Printf("add_int32 1+-2147483647 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(-2147483647); got != -2147483646 {
+ fmt.Printf("add_int32 -2147483647+1 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(-1); got != 0 {
+ fmt.Printf("add_int32 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(-1); got != 0 {
+ fmt.Printf("add_int32 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(0); got != 1 {
+ fmt.Printf("add_int32 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(0); got != 1 {
+ fmt.Printf("add_int32 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(1); got != 2 {
+ fmt.Printf("add_int32 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(1); got != 2 {
+ fmt.Printf("add_int32 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_int32_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("add_int32 1+2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_1_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("add_int32 2147483647+1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(-2147483648); got != -1 {
+ fmt.Printf("add_int32 2147483647+-2147483648 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(-2147483648); got != -1 {
+ fmt.Printf("add_int32 -2147483648+2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("add_int32 2147483647+-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(-2147483647); got != 0 {
+ fmt.Printf("add_int32 -2147483647+2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(-1); got != 2147483646 {
+ fmt.Printf("add_int32 2147483647+-1 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(-1); got != 2147483646 {
+ fmt.Printf("add_int32 -1+2147483647 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(0); got != 2147483647 {
+ fmt.Printf("add_int32 2147483647+0 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(0); got != 2147483647 {
+ fmt.Printf("add_int32 0+2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(1); got != -2147483648 {
+ fmt.Printf("add_int32 2147483647+1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(1); got != -2147483648 {
+ fmt.Printf("add_int32 1+2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := add_2147483647_int32_ssa(2147483647); got != -2 {
+ fmt.Printf("add_int32 2147483647+2147483647 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int32_2147483647_ssa(2147483647); got != -2 {
+ fmt.Printf("add_int32 2147483647+2147483647 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("sub_int32 -2147483648--2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(-2147483648); got != 0 {
+ fmt.Printf("sub_int32 -2147483648--2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(-2147483647); got != -1 {
+ fmt.Printf("sub_int32 -2147483648--2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(-2147483647); got != 1 {
+ fmt.Printf("sub_int32 -2147483647--2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(-1); got != -2147483647 {
+ fmt.Printf("sub_int32 -2147483648--1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(-1); got != 2147483647 {
+ fmt.Printf("sub_int32 -1--2147483648 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(0); got != -2147483648 {
+ fmt.Printf("sub_int32 -2147483648-0 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(0); got != -2147483648 {
+ fmt.Printf("sub_int32 0--2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(1); got != 2147483647 {
+ fmt.Printf("sub_int32 -2147483648-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(1); got != -2147483647 {
+ fmt.Printf("sub_int32 1--2147483648 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483648_int32_ssa(2147483647); got != 1 {
+ fmt.Printf("sub_int32 -2147483648-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483648_ssa(2147483647); got != -1 {
+ fmt.Printf("sub_int32 2147483647--2147483648 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(-2147483648); got != 1 {
+ fmt.Printf("sub_int32 -2147483647--2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(-2147483648); got != -1 {
+ fmt.Printf("sub_int32 -2147483648--2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("sub_int32 -2147483647--2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(-2147483647); got != 0 {
+ fmt.Printf("sub_int32 -2147483647--2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(-1); got != -2147483646 {
+ fmt.Printf("sub_int32 -2147483647--1 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(-1); got != 2147483646 {
+ fmt.Printf("sub_int32 -1--2147483647 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(0); got != -2147483647 {
+ fmt.Printf("sub_int32 -2147483647-0 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(0); got != 2147483647 {
+ fmt.Printf("sub_int32 0--2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(1); got != -2147483648 {
+ fmt.Printf("sub_int32 -2147483647-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(1); got != -2147483648 {
+ fmt.Printf("sub_int32 1--2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg2147483647_int32_ssa(2147483647); got != 2 {
+ fmt.Printf("sub_int32 -2147483647-2147483647 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg2147483647_ssa(2147483647); got != -2 {
+ fmt.Printf("sub_int32 2147483647--2147483647 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(-2147483648); got != 2147483647 {
+ fmt.Printf("sub_int32 -1--2147483648 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(-2147483648); got != -2147483647 {
+ fmt.Printf("sub_int32 -2147483648--1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(-2147483647); got != 2147483646 {
+ fmt.Printf("sub_int32 -1--2147483647 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(-2147483647); got != -2147483646 {
+ fmt.Printf("sub_int32 -2147483647--1 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(-1); got != 0 {
+ fmt.Printf("sub_int32 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(-1); got != 0 {
+ fmt.Printf("sub_int32 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(0); got != -1 {
+ fmt.Printf("sub_int32 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(0); got != 1 {
+ fmt.Printf("sub_int32 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(1); got != -2 {
+ fmt.Printf("sub_int32 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(1); got != 2 {
+ fmt.Printf("sub_int32 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int32_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("sub_int32 -1-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_Neg1_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("sub_int32 2147483647--1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("sub_int32 0--2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("sub_int32 -2147483648-0 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(-2147483647); got != 2147483647 {
+ fmt.Printf("sub_int32 0--2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("sub_int32 -2147483647-0 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(-1); got != 1 {
+ fmt.Printf("sub_int32 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(-1); got != -1 {
+ fmt.Printf("sub_int32 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(0); got != 0 {
+ fmt.Printf("sub_int32 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(0); got != 0 {
+ fmt.Printf("sub_int32 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(1); got != -1 {
+ fmt.Printf("sub_int32 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(1); got != 1 {
+ fmt.Printf("sub_int32 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int32_ssa(2147483647); got != -2147483647 {
+ fmt.Printf("sub_int32 0-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_0_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("sub_int32 2147483647-0 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(-2147483648); got != -2147483647 {
+ fmt.Printf("sub_int32 1--2147483648 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(-2147483648); got != 2147483647 {
+ fmt.Printf("sub_int32 -2147483648-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("sub_int32 1--2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("sub_int32 -2147483647-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(-1); got != 2 {
+ fmt.Printf("sub_int32 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(-1); got != -2 {
+ fmt.Printf("sub_int32 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(0); got != 1 {
+ fmt.Printf("sub_int32 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(0); got != -1 {
+ fmt.Printf("sub_int32 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(1); got != 0 {
+ fmt.Printf("sub_int32 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(1); got != 0 {
+ fmt.Printf("sub_int32 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int32_ssa(2147483647); got != -2147483646 {
+ fmt.Printf("sub_int32 1-2147483647 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_1_ssa(2147483647); got != 2147483646 {
+ fmt.Printf("sub_int32 2147483647-1 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(-2147483648); got != -1 {
+ fmt.Printf("sub_int32 2147483647--2147483648 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(-2147483648); got != 1 {
+ fmt.Printf("sub_int32 -2147483648-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(-2147483647); got != -2 {
+ fmt.Printf("sub_int32 2147483647--2147483647 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(-2147483647); got != 2 {
+ fmt.Printf("sub_int32 -2147483647-2147483647 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(-1); got != -2147483648 {
+ fmt.Printf("sub_int32 2147483647--1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(-1); got != -2147483648 {
+ fmt.Printf("sub_int32 -1-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(0); got != 2147483647 {
+ fmt.Printf("sub_int32 2147483647-0 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(0); got != -2147483647 {
+ fmt.Printf("sub_int32 0-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(1); got != 2147483646 {
+ fmt.Printf("sub_int32 2147483647-1 = %d, wanted 2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(1); got != -2147483646 {
+ fmt.Printf("sub_int32 1-2147483647 = %d, wanted -2147483646\n", got)
+ failed = true
+ }
+
+ if got := sub_2147483647_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("sub_int32 2147483647-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int32_2147483647_ssa(2147483647); got != 0 {
+ fmt.Printf("sub_int32 2147483647-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483648_int32_ssa(-2147483648); got != 1 {
+ fmt.Printf("div_int32 -2147483648/-2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(-2147483648); got != 1 {
+ fmt.Printf("div_int32 -2147483648/-2147483648 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483648_int32_ssa(-2147483647); got != 1 {
+ fmt.Printf("div_int32 -2147483648/-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(-2147483647); got != 0 {
+ fmt.Printf("div_int32 -2147483647/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483648_int32_ssa(-1); got != -2147483648 {
+ fmt.Printf("div_int32 -2147483648/-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(-1); got != 0 {
+ fmt.Printf("div_int32 -1/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(0); got != 0 {
+ fmt.Printf("div_int32 0/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483648_int32_ssa(1); got != -2147483648 {
+ fmt.Printf("div_int32 -2147483648/1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(1); got != 0 {
+ fmt.Printf("div_int32 1/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483648_int32_ssa(2147483647); got != -1 {
+ fmt.Printf("div_int32 -2147483648/2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483648_ssa(2147483647); got != 0 {
+ fmt.Printf("div_int32 2147483647/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483647_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("div_int32 -2147483647/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(-2147483648); got != 1 {
+ fmt.Printf("div_int32 -2147483648/-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483647_int32_ssa(-2147483647); got != 1 {
+ fmt.Printf("div_int32 -2147483647/-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(-2147483647); got != 1 {
+ fmt.Printf("div_int32 -2147483647/-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483647_int32_ssa(-1); got != 2147483647 {
+ fmt.Printf("div_int32 -2147483647/-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(-1); got != 0 {
+ fmt.Printf("div_int32 -1/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(0); got != 0 {
+ fmt.Printf("div_int32 0/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483647_int32_ssa(1); got != -2147483647 {
+ fmt.Printf("div_int32 -2147483647/1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(1); got != 0 {
+ fmt.Printf("div_int32 1/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg2147483647_int32_ssa(2147483647); got != -1 {
+ fmt.Printf("div_int32 -2147483647/2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg2147483647_ssa(2147483647); got != -1 {
+ fmt.Printf("div_int32 2147483647/-2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("div_int32 -1/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("div_int32 -2147483648/-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("div_int32 -1/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(-2147483647); got != 2147483647 {
+ fmt.Printf("div_int32 -2147483647/-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int32_ssa(-1); got != 1 {
+ fmt.Printf("div_int32 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("div_int32 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(0); got != 0 {
+ fmt.Printf("div_int32 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int32_ssa(1); got != -1 {
+ fmt.Printf("div_int32 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(1); got != -1 {
+ fmt.Printf("div_int32 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("div_int32 -1/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_Neg1_ssa(2147483647); got != -2147483647 {
+ fmt.Printf("div_int32 2147483647/-1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_0_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("div_int32 0/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("div_int32 0/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int32_ssa(-1); got != 0 {
+ fmt.Printf("div_int32 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int32_ssa(1); got != 0 {
+ fmt.Printf("div_int32 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("div_int32 0/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("div_int32 1/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("div_int32 -2147483648/1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := div_1_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("div_int32 1/-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("div_int32 -2147483647/1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_1_int32_ssa(-1); got != -1 {
+ fmt.Printf("div_int32 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(-1); got != -1 {
+ fmt.Printf("div_int32 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(0); got != 0 {
+ fmt.Printf("div_int32 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int32_ssa(1); got != 1 {
+ fmt.Printf("div_int32 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(1); got != 1 {
+ fmt.Printf("div_int32 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("div_int32 1/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_1_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("div_int32 2147483647/1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_2147483647_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("div_int32 2147483647/-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(-2147483648); got != -1 {
+ fmt.Printf("div_int32 -2147483648/2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_2147483647_int32_ssa(-2147483647); got != -1 {
+ fmt.Printf("div_int32 2147483647/-2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(-2147483647); got != -1 {
+ fmt.Printf("div_int32 -2147483647/2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_2147483647_int32_ssa(-1); got != -2147483647 {
+ fmt.Printf("div_int32 2147483647/-1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(-1); got != 0 {
+ fmt.Printf("div_int32 -1/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(0); got != 0 {
+ fmt.Printf("div_int32 0/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_2147483647_int32_ssa(1); got != 2147483647 {
+ fmt.Printf("div_int32 2147483647/1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(1); got != 0 {
+ fmt.Printf("div_int32 1/2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_2147483647_int32_ssa(2147483647); got != 1 {
+ fmt.Printf("div_int32 2147483647/2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int32_2147483647_ssa(2147483647); got != 1 {
+ fmt.Printf("div_int32 2147483647/2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("mul_int32 -2147483648*-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(-2147483648); got != 0 {
+ fmt.Printf("mul_int32 -2147483648*-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(-2147483647); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483647*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(-1); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(-1); got != -2147483648 {
+ fmt.Printf("mul_int32 -1*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 -2147483648*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(1); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(1); got != -2147483648 {
+ fmt.Printf("mul_int32 1*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483648_int32_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483648_ssa(2147483647); got != -2147483648 {
+ fmt.Printf("mul_int32 2147483647*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483647*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*-2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(-2147483647); got != 1 {
+ fmt.Printf("mul_int32 -2147483647*-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(-2147483647); got != 1 {
+ fmt.Printf("mul_int32 -2147483647*-2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(-1); got != 2147483647 {
+ fmt.Printf("mul_int32 -2147483647*-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(-1); got != 2147483647 {
+ fmt.Printf("mul_int32 -1*-2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 -2147483647*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(1); got != -2147483647 {
+ fmt.Printf("mul_int32 -2147483647*1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(1); got != -2147483647 {
+ fmt.Printf("mul_int32 1*-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg2147483647_int32_ssa(2147483647); got != -1 {
+ fmt.Printf("mul_int32 -2147483647*2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg2147483647_ssa(2147483647); got != -1 {
+ fmt.Printf("mul_int32 2147483647*-2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -1*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*-1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(-2147483647); got != 2147483647 {
+ fmt.Printf("mul_int32 -1*-2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(-2147483647); got != 2147483647 {
+ fmt.Printf("mul_int32 -2147483647*-1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(-1); got != 1 {
+ fmt.Printf("mul_int32 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("mul_int32 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(1); got != -1 {
+ fmt.Printf("mul_int32 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(1); got != -1 {
+ fmt.Printf("mul_int32 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int32_ssa(2147483647); got != -2147483647 {
+ fmt.Printf("mul_int32 -1*2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_Neg1_ssa(2147483647); got != -2147483647 {
+ fmt.Printf("mul_int32 2147483647*-1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(-2147483648); got != 0 {
+ fmt.Printf("mul_int32 0*-2147483648 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(-2147483648); got != 0 {
+ fmt.Printf("mul_int32 -2147483648*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(-2147483647); got != 0 {
+ fmt.Printf("mul_int32 0*-2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(-2147483647); got != 0 {
+ fmt.Printf("mul_int32 -2147483647*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(-1); got != 0 {
+ fmt.Printf("mul_int32 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(-1); got != 0 {
+ fmt.Printf("mul_int32 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(1); got != 0 {
+ fmt.Printf("mul_int32 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(1); got != 0 {
+ fmt.Printf("mul_int32 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int32_ssa(2147483647); got != 0 {
+ fmt.Printf("mul_int32 0*2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_0_ssa(2147483647); got != 0 {
+ fmt.Printf("mul_int32 2147483647*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 1*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*1 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("mul_int32 1*-2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(-2147483647); got != -2147483647 {
+ fmt.Printf("mul_int32 -2147483647*1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(-1); got != -1 {
+ fmt.Printf("mul_int32 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(-1); got != -1 {
+ fmt.Printf("mul_int32 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(1); got != 1 {
+ fmt.Printf("mul_int32 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(1); got != 1 {
+ fmt.Printf("mul_int32 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int32_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("mul_int32 1*2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_1_ssa(2147483647); got != 2147483647 {
+ fmt.Printf("mul_int32 2147483647*1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 2147483647*-2147483648 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(-2147483648); got != -2147483648 {
+ fmt.Printf("mul_int32 -2147483648*2147483647 = %d, wanted -2147483648\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(-2147483647); got != -1 {
+ fmt.Printf("mul_int32 2147483647*-2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(-2147483647); got != -1 {
+ fmt.Printf("mul_int32 -2147483647*2147483647 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(-1); got != -2147483647 {
+ fmt.Printf("mul_int32 2147483647*-1 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(-1); got != -2147483647 {
+ fmt.Printf("mul_int32 -1*2147483647 = %d, wanted -2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 2147483647*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(0); got != 0 {
+ fmt.Printf("mul_int32 0*2147483647 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(1); got != 2147483647 {
+ fmt.Printf("mul_int32 2147483647*1 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(1); got != 2147483647 {
+ fmt.Printf("mul_int32 1*2147483647 = %d, wanted 2147483647\n", got)
+ failed = true
+ }
+
+ if got := mul_2147483647_int32_ssa(2147483647); got != 1 {
+ fmt.Printf("mul_int32 2147483647*2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int32_2147483647_ssa(2147483647); got != 1 {
+ fmt.Printf("mul_int32 2147483647*2147483647 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint16_ssa(0); got != 0 {
+ fmt.Printf("add_uint16 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_0_ssa(0); got != 0 {
+ fmt.Printf("add_uint16 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint16_ssa(1); got != 1 {
+ fmt.Printf("add_uint16 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_0_ssa(1); got != 1 {
+ fmt.Printf("add_uint16 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint16_ssa(65535); got != 65535 {
+ fmt.Printf("add_uint16 0+65535 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_0_ssa(65535); got != 65535 {
+ fmt.Printf("add_uint16 65535+0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint16_ssa(0); got != 1 {
+ fmt.Printf("add_uint16 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_1_ssa(0); got != 1 {
+ fmt.Printf("add_uint16 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint16_ssa(1); got != 2 {
+ fmt.Printf("add_uint16 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_1_ssa(1); got != 2 {
+ fmt.Printf("add_uint16 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint16_ssa(65535); got != 0 {
+ fmt.Printf("add_uint16 1+65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_1_ssa(65535); got != 0 {
+ fmt.Printf("add_uint16 65535+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_65535_uint16_ssa(0); got != 65535 {
+ fmt.Printf("add_uint16 65535+0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_65535_ssa(0); got != 65535 {
+ fmt.Printf("add_uint16 0+65535 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := add_65535_uint16_ssa(1); got != 0 {
+ fmt.Printf("add_uint16 65535+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_65535_ssa(1); got != 0 {
+ fmt.Printf("add_uint16 1+65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_65535_uint16_ssa(65535); got != 65534 {
+ fmt.Printf("add_uint16 65535+65535 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := add_uint16_65535_ssa(65535); got != 65534 {
+ fmt.Printf("add_uint16 65535+65535 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint16_ssa(0); got != 0 {
+ fmt.Printf("sub_uint16 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_0_ssa(0); got != 0 {
+ fmt.Printf("sub_uint16 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint16_ssa(1); got != 65535 {
+ fmt.Printf("sub_uint16 0-1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_0_ssa(1); got != 1 {
+ fmt.Printf("sub_uint16 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint16_ssa(65535); got != 1 {
+ fmt.Printf("sub_uint16 0-65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_0_ssa(65535); got != 65535 {
+ fmt.Printf("sub_uint16 65535-0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint16_ssa(0); got != 1 {
+ fmt.Printf("sub_uint16 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_1_ssa(0); got != 65535 {
+ fmt.Printf("sub_uint16 0-1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint16_ssa(1); got != 0 {
+ fmt.Printf("sub_uint16 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_1_ssa(1); got != 0 {
+ fmt.Printf("sub_uint16 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint16_ssa(65535); got != 2 {
+ fmt.Printf("sub_uint16 1-65535 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_1_ssa(65535); got != 65534 {
+ fmt.Printf("sub_uint16 65535-1 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := sub_65535_uint16_ssa(0); got != 65535 {
+ fmt.Printf("sub_uint16 65535-0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_65535_ssa(0); got != 1 {
+ fmt.Printf("sub_uint16 0-65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_65535_uint16_ssa(1); got != 65534 {
+ fmt.Printf("sub_uint16 65535-1 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_65535_ssa(1); got != 2 {
+ fmt.Printf("sub_uint16 1-65535 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_65535_uint16_ssa(65535); got != 0 {
+ fmt.Printf("sub_uint16 65535-65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint16_65535_ssa(65535); got != 0 {
+ fmt.Printf("sub_uint16 65535-65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint16_ssa(1); got != 0 {
+ fmt.Printf("div_uint16 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint16_ssa(65535); got != 0 {
+ fmt.Printf("div_uint16 0/65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_1_ssa(0); got != 0 {
+ fmt.Printf("div_uint16 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint16_ssa(1); got != 1 {
+ fmt.Printf("div_uint16 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_1_ssa(1); got != 1 {
+ fmt.Printf("div_uint16 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint16_ssa(65535); got != 0 {
+ fmt.Printf("div_uint16 1/65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_1_ssa(65535); got != 65535 {
+ fmt.Printf("div_uint16 65535/1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_65535_ssa(0); got != 0 {
+ fmt.Printf("div_uint16 0/65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_65535_uint16_ssa(1); got != 65535 {
+ fmt.Printf("div_uint16 65535/1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_65535_ssa(1); got != 0 {
+ fmt.Printf("div_uint16 1/65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_65535_uint16_ssa(65535); got != 1 {
+ fmt.Printf("div_uint16 65535/65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint16_65535_ssa(65535); got != 1 {
+ fmt.Printf("div_uint16 65535/65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint16_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_0_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint16_ssa(1); got != 0 {
+ fmt.Printf("mul_uint16 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_0_ssa(1); got != 0 {
+ fmt.Printf("mul_uint16 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint16_ssa(65535); got != 0 {
+ fmt.Printf("mul_uint16 0*65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_0_ssa(65535); got != 0 {
+ fmt.Printf("mul_uint16 65535*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint16_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_1_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint16_ssa(1); got != 1 {
+ fmt.Printf("mul_uint16 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_1_ssa(1); got != 1 {
+ fmt.Printf("mul_uint16 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint16_ssa(65535); got != 65535 {
+ fmt.Printf("mul_uint16 1*65535 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_1_ssa(65535); got != 65535 {
+ fmt.Printf("mul_uint16 65535*1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := mul_65535_uint16_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 65535*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_65535_ssa(0); got != 0 {
+ fmt.Printf("mul_uint16 0*65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_65535_uint16_ssa(1); got != 65535 {
+ fmt.Printf("mul_uint16 65535*1 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_65535_ssa(1); got != 65535 {
+ fmt.Printf("mul_uint16 1*65535 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := mul_65535_uint16_ssa(65535); got != 1 {
+ fmt.Printf("mul_uint16 65535*65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint16_65535_ssa(65535); got != 1 {
+ fmt.Printf("mul_uint16 65535*65535 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint16_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint16 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_0_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint16 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint16_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint16 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_0_ssa(1); got != 1 {
+ fmt.Printf("lsh_uint16 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint16_ssa(65535); got != 0 {
+ fmt.Printf("lsh_uint16 0<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_0_ssa(65535); got != 65535 {
+ fmt.Printf("lsh_uint16 65535<<0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint16_ssa(0); got != 1 {
+ fmt.Printf("lsh_uint16 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_1_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint16 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint16_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint16 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_1_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint16 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint16_ssa(65535); got != 0 {
+ fmt.Printf("lsh_uint16 1<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_1_ssa(65535); got != 65534 {
+ fmt.Printf("lsh_uint16 65535<<1 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := lsh_65535_uint16_ssa(0); got != 65535 {
+ fmt.Printf("lsh_uint16 65535<<0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_65535_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint16 0<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_65535_uint16_ssa(1); got != 65534 {
+ fmt.Printf("lsh_uint16 65535<<1 = %d, wanted 65534\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_65535_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint16 1<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_65535_uint16_ssa(65535); got != 0 {
+ fmt.Printf("lsh_uint16 65535<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint16_65535_ssa(65535); got != 0 {
+ fmt.Printf("lsh_uint16 65535<<65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint16_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint16 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_0_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint16 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint16_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint16 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_0_ssa(1); got != 1 {
+ fmt.Printf("rsh_uint16 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint16_ssa(65535); got != 0 {
+ fmt.Printf("rsh_uint16 0>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_0_ssa(65535); got != 65535 {
+ fmt.Printf("rsh_uint16 65535>>0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint16_ssa(0); got != 1 {
+ fmt.Printf("rsh_uint16 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_1_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint16 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint16_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint16 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_1_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint16 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint16_ssa(65535); got != 0 {
+ fmt.Printf("rsh_uint16 1>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_1_ssa(65535); got != 32767 {
+ fmt.Printf("rsh_uint16 65535>>1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := rsh_65535_uint16_ssa(0); got != 65535 {
+ fmt.Printf("rsh_uint16 65535>>0 = %d, wanted 65535\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_65535_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint16 0>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_65535_uint16_ssa(1); got != 32767 {
+ fmt.Printf("rsh_uint16 65535>>1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_65535_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint16 1>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_65535_uint16_ssa(65535); got != 0 {
+ fmt.Printf("rsh_uint16 65535>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint16_65535_ssa(65535); got != 0 {
+ fmt.Printf("rsh_uint16 65535>>65535 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(-32768); got != 0 {
+ fmt.Printf("add_int16 -32768+-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(-32768); got != 0 {
+ fmt.Printf("add_int16 -32768+-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(-32767); got != 1 {
+ fmt.Printf("add_int16 -32768+-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(-32767); got != 1 {
+ fmt.Printf("add_int16 -32767+-32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(-1); got != 32767 {
+ fmt.Printf("add_int16 -32768+-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(-1); got != 32767 {
+ fmt.Printf("add_int16 -1+-32768 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(0); got != -32768 {
+ fmt.Printf("add_int16 -32768+0 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(0); got != -32768 {
+ fmt.Printf("add_int16 0+-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(1); got != -32767 {
+ fmt.Printf("add_int16 -32768+1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(1); got != -32767 {
+ fmt.Printf("add_int16 1+-32768 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(32766); got != -2 {
+ fmt.Printf("add_int16 -32768+32766 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(32766); got != -2 {
+ fmt.Printf("add_int16 32766+-32768 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32768_int16_ssa(32767); got != -1 {
+ fmt.Printf("add_int16 -32768+32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32768_ssa(32767); got != -1 {
+ fmt.Printf("add_int16 32767+-32768 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(-32768); got != 1 {
+ fmt.Printf("add_int16 -32767+-32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(-32768); got != 1 {
+ fmt.Printf("add_int16 -32768+-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(-32767); got != 2 {
+ fmt.Printf("add_int16 -32767+-32767 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(-32767); got != 2 {
+ fmt.Printf("add_int16 -32767+-32767 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(-1); got != -32768 {
+ fmt.Printf("add_int16 -32767+-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(-1); got != -32768 {
+ fmt.Printf("add_int16 -1+-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(0); got != -32767 {
+ fmt.Printf("add_int16 -32767+0 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(0); got != -32767 {
+ fmt.Printf("add_int16 0+-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(1); got != -32766 {
+ fmt.Printf("add_int16 -32767+1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(1); got != -32766 {
+ fmt.Printf("add_int16 1+-32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(32766); got != -1 {
+ fmt.Printf("add_int16 -32767+32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(32766); got != -1 {
+ fmt.Printf("add_int16 32766+-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg32767_int16_ssa(32767); got != 0 {
+ fmt.Printf("add_int16 -32767+32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg32767_ssa(32767); got != 0 {
+ fmt.Printf("add_int16 32767+-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(-32768); got != 32767 {
+ fmt.Printf("add_int16 -1+-32768 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(-32768); got != 32767 {
+ fmt.Printf("add_int16 -32768+-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(-32767); got != -32768 {
+ fmt.Printf("add_int16 -1+-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(-32767); got != -32768 {
+ fmt.Printf("add_int16 -32767+-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(-1); got != -2 {
+ fmt.Printf("add_int16 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(-1); got != -2 {
+ fmt.Printf("add_int16 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(0); got != -1 {
+ fmt.Printf("add_int16 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(0); got != -1 {
+ fmt.Printf("add_int16 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(1); got != 0 {
+ fmt.Printf("add_int16 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(1); got != 0 {
+ fmt.Printf("add_int16 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(32766); got != 32765 {
+ fmt.Printf("add_int16 -1+32766 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(32766); got != 32765 {
+ fmt.Printf("add_int16 32766+-1 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int16_ssa(32767); got != 32766 {
+ fmt.Printf("add_int16 -1+32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_Neg1_ssa(32767); got != 32766 {
+ fmt.Printf("add_int16 32767+-1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("add_int16 0+-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(-32768); got != -32768 {
+ fmt.Printf("add_int16 -32768+0 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(-32767); got != -32767 {
+ fmt.Printf("add_int16 0+-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(-32767); got != -32767 {
+ fmt.Printf("add_int16 -32767+0 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(-1); got != -1 {
+ fmt.Printf("add_int16 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(-1); got != -1 {
+ fmt.Printf("add_int16 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(0); got != 0 {
+ fmt.Printf("add_int16 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(0); got != 0 {
+ fmt.Printf("add_int16 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(1); got != 1 {
+ fmt.Printf("add_int16 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(1); got != 1 {
+ fmt.Printf("add_int16 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(32766); got != 32766 {
+ fmt.Printf("add_int16 0+32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(32766); got != 32766 {
+ fmt.Printf("add_int16 32766+0 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_0_int16_ssa(32767); got != 32767 {
+ fmt.Printf("add_int16 0+32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_0_ssa(32767); got != 32767 {
+ fmt.Printf("add_int16 32767+0 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(-32768); got != -32767 {
+ fmt.Printf("add_int16 1+-32768 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(-32768); got != -32767 {
+ fmt.Printf("add_int16 -32768+1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(-32767); got != -32766 {
+ fmt.Printf("add_int16 1+-32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(-32767); got != -32766 {
+ fmt.Printf("add_int16 -32767+1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(-1); got != 0 {
+ fmt.Printf("add_int16 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(-1); got != 0 {
+ fmt.Printf("add_int16 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(0); got != 1 {
+ fmt.Printf("add_int16 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(0); got != 1 {
+ fmt.Printf("add_int16 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(1); got != 2 {
+ fmt.Printf("add_int16 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(1); got != 2 {
+ fmt.Printf("add_int16 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(32766); got != 32767 {
+ fmt.Printf("add_int16 1+32766 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(32766); got != 32767 {
+ fmt.Printf("add_int16 32766+1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_1_int16_ssa(32767); got != -32768 {
+ fmt.Printf("add_int16 1+32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_1_ssa(32767); got != -32768 {
+ fmt.Printf("add_int16 32767+1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(-32768); got != -2 {
+ fmt.Printf("add_int16 32766+-32768 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(-32768); got != -2 {
+ fmt.Printf("add_int16 -32768+32766 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(-32767); got != -1 {
+ fmt.Printf("add_int16 32766+-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(-32767); got != -1 {
+ fmt.Printf("add_int16 -32767+32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(-1); got != 32765 {
+ fmt.Printf("add_int16 32766+-1 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(-1); got != 32765 {
+ fmt.Printf("add_int16 -1+32766 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(0); got != 32766 {
+ fmt.Printf("add_int16 32766+0 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(0); got != 32766 {
+ fmt.Printf("add_int16 0+32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(1); got != 32767 {
+ fmt.Printf("add_int16 32766+1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(1); got != 32767 {
+ fmt.Printf("add_int16 1+32766 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(32766); got != -4 {
+ fmt.Printf("add_int16 32766+32766 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(32766); got != -4 {
+ fmt.Printf("add_int16 32766+32766 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_32766_int16_ssa(32767); got != -3 {
+ fmt.Printf("add_int16 32766+32767 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32766_ssa(32767); got != -3 {
+ fmt.Printf("add_int16 32767+32766 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(-32768); got != -1 {
+ fmt.Printf("add_int16 32767+-32768 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(-32768); got != -1 {
+ fmt.Printf("add_int16 -32768+32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(-32767); got != 0 {
+ fmt.Printf("add_int16 32767+-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(-32767); got != 0 {
+ fmt.Printf("add_int16 -32767+32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(-1); got != 32766 {
+ fmt.Printf("add_int16 32767+-1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(-1); got != 32766 {
+ fmt.Printf("add_int16 -1+32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(0); got != 32767 {
+ fmt.Printf("add_int16 32767+0 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(0); got != 32767 {
+ fmt.Printf("add_int16 0+32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(1); got != -32768 {
+ fmt.Printf("add_int16 32767+1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(1); got != -32768 {
+ fmt.Printf("add_int16 1+32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(32766); got != -3 {
+ fmt.Printf("add_int16 32767+32766 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(32766); got != -3 {
+ fmt.Printf("add_int16 32766+32767 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_32767_int16_ssa(32767); got != -2 {
+ fmt.Printf("add_int16 32767+32767 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int16_32767_ssa(32767); got != -2 {
+ fmt.Printf("add_int16 32767+32767 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(-32768); got != 0 {
+ fmt.Printf("sub_int16 -32768--32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(-32768); got != 0 {
+ fmt.Printf("sub_int16 -32768--32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(-32767); got != -1 {
+ fmt.Printf("sub_int16 -32768--32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(-32767); got != 1 {
+ fmt.Printf("sub_int16 -32767--32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(-1); got != -32767 {
+ fmt.Printf("sub_int16 -32768--1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(-1); got != 32767 {
+ fmt.Printf("sub_int16 -1--32768 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(0); got != -32768 {
+ fmt.Printf("sub_int16 -32768-0 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(0); got != -32768 {
+ fmt.Printf("sub_int16 0--32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(1); got != 32767 {
+ fmt.Printf("sub_int16 -32768-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(1); got != -32767 {
+ fmt.Printf("sub_int16 1--32768 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(32766); got != 2 {
+ fmt.Printf("sub_int16 -32768-32766 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(32766); got != -2 {
+ fmt.Printf("sub_int16 32766--32768 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32768_int16_ssa(32767); got != 1 {
+ fmt.Printf("sub_int16 -32768-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32768_ssa(32767); got != -1 {
+ fmt.Printf("sub_int16 32767--32768 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(-32768); got != 1 {
+ fmt.Printf("sub_int16 -32767--32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(-32768); got != -1 {
+ fmt.Printf("sub_int16 -32768--32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(-32767); got != 0 {
+ fmt.Printf("sub_int16 -32767--32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(-32767); got != 0 {
+ fmt.Printf("sub_int16 -32767--32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(-1); got != -32766 {
+ fmt.Printf("sub_int16 -32767--1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(-1); got != 32766 {
+ fmt.Printf("sub_int16 -1--32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(0); got != -32767 {
+ fmt.Printf("sub_int16 -32767-0 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(0); got != 32767 {
+ fmt.Printf("sub_int16 0--32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(1); got != -32768 {
+ fmt.Printf("sub_int16 -32767-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(1); got != -32768 {
+ fmt.Printf("sub_int16 1--32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(32766); got != 3 {
+ fmt.Printf("sub_int16 -32767-32766 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(32766); got != -3 {
+ fmt.Printf("sub_int16 32766--32767 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg32767_int16_ssa(32767); got != 2 {
+ fmt.Printf("sub_int16 -32767-32767 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg32767_ssa(32767); got != -2 {
+ fmt.Printf("sub_int16 32767--32767 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(-32768); got != 32767 {
+ fmt.Printf("sub_int16 -1--32768 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(-32768); got != -32767 {
+ fmt.Printf("sub_int16 -32768--1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(-32767); got != 32766 {
+ fmt.Printf("sub_int16 -1--32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(-32767); got != -32766 {
+ fmt.Printf("sub_int16 -32767--1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(-1); got != 0 {
+ fmt.Printf("sub_int16 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(-1); got != 0 {
+ fmt.Printf("sub_int16 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(0); got != -1 {
+ fmt.Printf("sub_int16 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(0); got != 1 {
+ fmt.Printf("sub_int16 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(1); got != -2 {
+ fmt.Printf("sub_int16 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(1); got != 2 {
+ fmt.Printf("sub_int16 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(32766); got != -32767 {
+ fmt.Printf("sub_int16 -1-32766 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(32766); got != 32767 {
+ fmt.Printf("sub_int16 32766--1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int16_ssa(32767); got != -32768 {
+ fmt.Printf("sub_int16 -1-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_Neg1_ssa(32767); got != -32768 {
+ fmt.Printf("sub_int16 32767--1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("sub_int16 0--32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(-32768); got != -32768 {
+ fmt.Printf("sub_int16 -32768-0 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(-32767); got != 32767 {
+ fmt.Printf("sub_int16 0--32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(-32767); got != -32767 {
+ fmt.Printf("sub_int16 -32767-0 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(-1); got != 1 {
+ fmt.Printf("sub_int16 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(-1); got != -1 {
+ fmt.Printf("sub_int16 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(0); got != 0 {
+ fmt.Printf("sub_int16 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(0); got != 0 {
+ fmt.Printf("sub_int16 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(1); got != -1 {
+ fmt.Printf("sub_int16 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(1); got != 1 {
+ fmt.Printf("sub_int16 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(32766); got != -32766 {
+ fmt.Printf("sub_int16 0-32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(32766); got != 32766 {
+ fmt.Printf("sub_int16 32766-0 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int16_ssa(32767); got != -32767 {
+ fmt.Printf("sub_int16 0-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_0_ssa(32767); got != 32767 {
+ fmt.Printf("sub_int16 32767-0 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(-32768); got != -32767 {
+ fmt.Printf("sub_int16 1--32768 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(-32768); got != 32767 {
+ fmt.Printf("sub_int16 -32768-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(-32767); got != -32768 {
+ fmt.Printf("sub_int16 1--32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(-32767); got != -32768 {
+ fmt.Printf("sub_int16 -32767-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(-1); got != 2 {
+ fmt.Printf("sub_int16 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(-1); got != -2 {
+ fmt.Printf("sub_int16 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(0); got != 1 {
+ fmt.Printf("sub_int16 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(0); got != -1 {
+ fmt.Printf("sub_int16 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(1); got != 0 {
+ fmt.Printf("sub_int16 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(1); got != 0 {
+ fmt.Printf("sub_int16 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(32766); got != -32765 {
+ fmt.Printf("sub_int16 1-32766 = %d, wanted -32765\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(32766); got != 32765 {
+ fmt.Printf("sub_int16 32766-1 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int16_ssa(32767); got != -32766 {
+ fmt.Printf("sub_int16 1-32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_1_ssa(32767); got != 32766 {
+ fmt.Printf("sub_int16 32767-1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(-32768); got != -2 {
+ fmt.Printf("sub_int16 32766--32768 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(-32768); got != 2 {
+ fmt.Printf("sub_int16 -32768-32766 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(-32767); got != -3 {
+ fmt.Printf("sub_int16 32766--32767 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(-32767); got != 3 {
+ fmt.Printf("sub_int16 -32767-32766 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(-1); got != 32767 {
+ fmt.Printf("sub_int16 32766--1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(-1); got != -32767 {
+ fmt.Printf("sub_int16 -1-32766 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(0); got != 32766 {
+ fmt.Printf("sub_int16 32766-0 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(0); got != -32766 {
+ fmt.Printf("sub_int16 0-32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(1); got != 32765 {
+ fmt.Printf("sub_int16 32766-1 = %d, wanted 32765\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(1); got != -32765 {
+ fmt.Printf("sub_int16 1-32766 = %d, wanted -32765\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(32766); got != 0 {
+ fmt.Printf("sub_int16 32766-32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(32766); got != 0 {
+ fmt.Printf("sub_int16 32766-32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_32766_int16_ssa(32767); got != -1 {
+ fmt.Printf("sub_int16 32766-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32766_ssa(32767); got != 1 {
+ fmt.Printf("sub_int16 32767-32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(-32768); got != -1 {
+ fmt.Printf("sub_int16 32767--32768 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(-32768); got != 1 {
+ fmt.Printf("sub_int16 -32768-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(-32767); got != -2 {
+ fmt.Printf("sub_int16 32767--32767 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(-32767); got != 2 {
+ fmt.Printf("sub_int16 -32767-32767 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(-1); got != -32768 {
+ fmt.Printf("sub_int16 32767--1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(-1); got != -32768 {
+ fmt.Printf("sub_int16 -1-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(0); got != 32767 {
+ fmt.Printf("sub_int16 32767-0 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(0); got != -32767 {
+ fmt.Printf("sub_int16 0-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(1); got != 32766 {
+ fmt.Printf("sub_int16 32767-1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(1); got != -32766 {
+ fmt.Printf("sub_int16 1-32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(32766); got != 1 {
+ fmt.Printf("sub_int16 32767-32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(32766); got != -1 {
+ fmt.Printf("sub_int16 32766-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_32767_int16_ssa(32767); got != 0 {
+ fmt.Printf("sub_int16 32767-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int16_32767_ssa(32767); got != 0 {
+ fmt.Printf("sub_int16 32767-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(-32768); got != 1 {
+ fmt.Printf("div_int16 -32768/-32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(-32768); got != 1 {
+ fmt.Printf("div_int16 -32768/-32768 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(-32767); got != 1 {
+ fmt.Printf("div_int16 -32768/-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(-32767); got != 0 {
+ fmt.Printf("div_int16 -32767/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(-1); got != -32768 {
+ fmt.Printf("div_int16 -32768/-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(-1); got != 0 {
+ fmt.Printf("div_int16 -1/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(1); got != -32768 {
+ fmt.Printf("div_int16 -32768/1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(1); got != 0 {
+ fmt.Printf("div_int16 1/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(32766); got != -1 {
+ fmt.Printf("div_int16 -32768/32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 32766/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32768_int16_ssa(32767); got != -1 {
+ fmt.Printf("div_int16 -32768/32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32768_ssa(32767); got != 0 {
+ fmt.Printf("div_int16 32767/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 -32767/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(-32768); got != 1 {
+ fmt.Printf("div_int16 -32768/-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(-32767); got != 1 {
+ fmt.Printf("div_int16 -32767/-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(-32767); got != 1 {
+ fmt.Printf("div_int16 -32767/-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(-1); got != 32767 {
+ fmt.Printf("div_int16 -32767/-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(-1); got != 0 {
+ fmt.Printf("div_int16 -1/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(1); got != -32767 {
+ fmt.Printf("div_int16 -32767/1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(1); got != 0 {
+ fmt.Printf("div_int16 1/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(32766); got != -1 {
+ fmt.Printf("div_int16 -32767/32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 32766/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg32767_int16_ssa(32767); got != -1 {
+ fmt.Printf("div_int16 -32767/32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg32767_ssa(32767); got != -1 {
+ fmt.Printf("div_int16 32767/-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 -1/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(-32768); got != -32768 {
+ fmt.Printf("div_int16 -32768/-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(-32767); got != 0 {
+ fmt.Printf("div_int16 -1/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(-32767); got != 32767 {
+ fmt.Printf("div_int16 -32767/-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(-1); got != 1 {
+ fmt.Printf("div_int16 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("div_int16 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(1); got != -1 {
+ fmt.Printf("div_int16 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(1); got != -1 {
+ fmt.Printf("div_int16 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 -1/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(32766); got != -32766 {
+ fmt.Printf("div_int16 32766/-1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int16_ssa(32767); got != 0 {
+ fmt.Printf("div_int16 -1/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_Neg1_ssa(32767); got != -32767 {
+ fmt.Printf("div_int16 32767/-1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 0/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(-32767); got != 0 {
+ fmt.Printf("div_int16 0/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(-1); got != 0 {
+ fmt.Printf("div_int16 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(1); got != 0 {
+ fmt.Printf("div_int16 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 0/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int16_ssa(32767); got != 0 {
+ fmt.Printf("div_int16 0/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 1/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(-32768); got != -32768 {
+ fmt.Printf("div_int16 -32768/1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(-32767); got != 0 {
+ fmt.Printf("div_int16 1/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(-32767); got != -32767 {
+ fmt.Printf("div_int16 -32767/1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(-1); got != -1 {
+ fmt.Printf("div_int16 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(-1); got != -1 {
+ fmt.Printf("div_int16 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(1); got != 1 {
+ fmt.Printf("div_int16 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(1); got != 1 {
+ fmt.Printf("div_int16 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 1/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(32766); got != 32766 {
+ fmt.Printf("div_int16 32766/1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := div_1_int16_ssa(32767); got != 0 {
+ fmt.Printf("div_int16 1/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_1_ssa(32767); got != 32767 {
+ fmt.Printf("div_int16 32767/1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 32766/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(-32768); got != -1 {
+ fmt.Printf("div_int16 -32768/32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(-32767); got != 0 {
+ fmt.Printf("div_int16 32766/-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(-32767); got != -1 {
+ fmt.Printf("div_int16 -32767/32766 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(-1); got != -32766 {
+ fmt.Printf("div_int16 32766/-1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(-1); got != 0 {
+ fmt.Printf("div_int16 -1/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(1); got != 32766 {
+ fmt.Printf("div_int16 32766/1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(1); got != 0 {
+ fmt.Printf("div_int16 1/32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(32766); got != 1 {
+ fmt.Printf("div_int16 32766/32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(32766); got != 1 {
+ fmt.Printf("div_int16 32766/32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_32766_int16_ssa(32767); got != 0 {
+ fmt.Printf("div_int16 32766/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32766_ssa(32767); got != 1 {
+ fmt.Printf("div_int16 32767/32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(-32768); got != 0 {
+ fmt.Printf("div_int16 32767/-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(-32768); got != -1 {
+ fmt.Printf("div_int16 -32768/32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(-32767); got != -1 {
+ fmt.Printf("div_int16 32767/-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(-32767); got != -1 {
+ fmt.Printf("div_int16 -32767/32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(-1); got != -32767 {
+ fmt.Printf("div_int16 32767/-1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(-1); got != 0 {
+ fmt.Printf("div_int16 -1/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(0); got != 0 {
+ fmt.Printf("div_int16 0/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(1); got != 32767 {
+ fmt.Printf("div_int16 32767/1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(1); got != 0 {
+ fmt.Printf("div_int16 1/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(32766); got != 1 {
+ fmt.Printf("div_int16 32767/32766 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(32766); got != 0 {
+ fmt.Printf("div_int16 32766/32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_32767_int16_ssa(32767); got != 1 {
+ fmt.Printf("div_int16 32767/32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int16_32767_ssa(32767); got != 1 {
+ fmt.Printf("div_int16 32767/32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 -32768*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 -32768*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(-32767); got != -32768 {
+ fmt.Printf("mul_int16 -32768*-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(-32767); got != -32768 {
+ fmt.Printf("mul_int16 -32767*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(-1); got != -32768 {
+ fmt.Printf("mul_int16 -32768*-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(-1); got != -32768 {
+ fmt.Printf("mul_int16 -1*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 -32768*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(1); got != -32768 {
+ fmt.Printf("mul_int16 -32768*1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(1); got != -32768 {
+ fmt.Printf("mul_int16 1*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(32766); got != 0 {
+ fmt.Printf("mul_int16 -32768*32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(32766); got != 0 {
+ fmt.Printf("mul_int16 32766*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32768_int16_ssa(32767); got != -32768 {
+ fmt.Printf("mul_int16 -32768*32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32768_ssa(32767); got != -32768 {
+ fmt.Printf("mul_int16 32767*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -32767*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -32768*-32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(-32767); got != 1 {
+ fmt.Printf("mul_int16 -32767*-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(-32767); got != 1 {
+ fmt.Printf("mul_int16 -32767*-32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(-1); got != 32767 {
+ fmt.Printf("mul_int16 -32767*-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(-1); got != 32767 {
+ fmt.Printf("mul_int16 -1*-32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 -32767*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(1); got != -32767 {
+ fmt.Printf("mul_int16 -32767*1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(1); got != -32767 {
+ fmt.Printf("mul_int16 1*-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(32766); got != 32766 {
+ fmt.Printf("mul_int16 -32767*32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(32766); got != 32766 {
+ fmt.Printf("mul_int16 32766*-32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg32767_int16_ssa(32767); got != -1 {
+ fmt.Printf("mul_int16 -32767*32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg32767_ssa(32767); got != -1 {
+ fmt.Printf("mul_int16 32767*-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -1*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -32768*-1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(-32767); got != 32767 {
+ fmt.Printf("mul_int16 -1*-32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(-32767); got != 32767 {
+ fmt.Printf("mul_int16 -32767*-1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(-1); got != 1 {
+ fmt.Printf("mul_int16 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("mul_int16 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(1); got != -1 {
+ fmt.Printf("mul_int16 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(1); got != -1 {
+ fmt.Printf("mul_int16 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(32766); got != -32766 {
+ fmt.Printf("mul_int16 -1*32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(32766); got != -32766 {
+ fmt.Printf("mul_int16 32766*-1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int16_ssa(32767); got != -32767 {
+ fmt.Printf("mul_int16 -1*32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_Neg1_ssa(32767); got != -32767 {
+ fmt.Printf("mul_int16 32767*-1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 0*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 -32768*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(-32767); got != 0 {
+ fmt.Printf("mul_int16 0*-32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(-32767); got != 0 {
+ fmt.Printf("mul_int16 -32767*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(-1); got != 0 {
+ fmt.Printf("mul_int16 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(-1); got != 0 {
+ fmt.Printf("mul_int16 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(1); got != 0 {
+ fmt.Printf("mul_int16 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(1); got != 0 {
+ fmt.Printf("mul_int16 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(32766); got != 0 {
+ fmt.Printf("mul_int16 0*32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(32766); got != 0 {
+ fmt.Printf("mul_int16 32766*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int16_ssa(32767); got != 0 {
+ fmt.Printf("mul_int16 0*32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_0_ssa(32767); got != 0 {
+ fmt.Printf("mul_int16 32767*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 1*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -32768*1 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(-32767); got != -32767 {
+ fmt.Printf("mul_int16 1*-32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(-32767); got != -32767 {
+ fmt.Printf("mul_int16 -32767*1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(-1); got != -1 {
+ fmt.Printf("mul_int16 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(-1); got != -1 {
+ fmt.Printf("mul_int16 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(1); got != 1 {
+ fmt.Printf("mul_int16 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(1); got != 1 {
+ fmt.Printf("mul_int16 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(32766); got != 32766 {
+ fmt.Printf("mul_int16 1*32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(32766); got != 32766 {
+ fmt.Printf("mul_int16 32766*1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int16_ssa(32767); got != 32767 {
+ fmt.Printf("mul_int16 1*32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_1_ssa(32767); got != 32767 {
+ fmt.Printf("mul_int16 32767*1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 32766*-32768 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(-32768); got != 0 {
+ fmt.Printf("mul_int16 -32768*32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(-32767); got != 32766 {
+ fmt.Printf("mul_int16 32766*-32767 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(-32767); got != 32766 {
+ fmt.Printf("mul_int16 -32767*32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(-1); got != -32766 {
+ fmt.Printf("mul_int16 32766*-1 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(-1); got != -32766 {
+ fmt.Printf("mul_int16 -1*32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 32766*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*32766 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(1); got != 32766 {
+ fmt.Printf("mul_int16 32766*1 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(1); got != 32766 {
+ fmt.Printf("mul_int16 1*32766 = %d, wanted 32766\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(32766); got != 4 {
+ fmt.Printf("mul_int16 32766*32766 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(32766); got != 4 {
+ fmt.Printf("mul_int16 32766*32766 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_32766_int16_ssa(32767); got != -32766 {
+ fmt.Printf("mul_int16 32766*32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32766_ssa(32767); got != -32766 {
+ fmt.Printf("mul_int16 32767*32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 32767*-32768 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(-32768); got != -32768 {
+ fmt.Printf("mul_int16 -32768*32767 = %d, wanted -32768\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(-32767); got != -1 {
+ fmt.Printf("mul_int16 32767*-32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(-32767); got != -1 {
+ fmt.Printf("mul_int16 -32767*32767 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(-1); got != -32767 {
+ fmt.Printf("mul_int16 32767*-1 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(-1); got != -32767 {
+ fmt.Printf("mul_int16 -1*32767 = %d, wanted -32767\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 32767*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(0); got != 0 {
+ fmt.Printf("mul_int16 0*32767 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(1); got != 32767 {
+ fmt.Printf("mul_int16 32767*1 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(1); got != 32767 {
+ fmt.Printf("mul_int16 1*32767 = %d, wanted 32767\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(32766); got != -32766 {
+ fmt.Printf("mul_int16 32767*32766 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(32766); got != -32766 {
+ fmt.Printf("mul_int16 32766*32767 = %d, wanted -32766\n", got)
+ failed = true
+ }
+
+ if got := mul_32767_int16_ssa(32767); got != 1 {
+ fmt.Printf("mul_int16 32767*32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int16_32767_ssa(32767); got != 1 {
+ fmt.Printf("mul_int16 32767*32767 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint8_ssa(0); got != 0 {
+ fmt.Printf("add_uint8 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_0_ssa(0); got != 0 {
+ fmt.Printf("add_uint8 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint8_ssa(1); got != 1 {
+ fmt.Printf("add_uint8 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_0_ssa(1); got != 1 {
+ fmt.Printf("add_uint8 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_uint8_ssa(255); got != 255 {
+ fmt.Printf("add_uint8 0+255 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_0_ssa(255); got != 255 {
+ fmt.Printf("add_uint8 255+0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint8_ssa(0); got != 1 {
+ fmt.Printf("add_uint8 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_1_ssa(0); got != 1 {
+ fmt.Printf("add_uint8 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint8_ssa(1); got != 2 {
+ fmt.Printf("add_uint8 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_1_ssa(1); got != 2 {
+ fmt.Printf("add_uint8 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_uint8_ssa(255); got != 0 {
+ fmt.Printf("add_uint8 1+255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_1_ssa(255); got != 0 {
+ fmt.Printf("add_uint8 255+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_255_uint8_ssa(0); got != 255 {
+ fmt.Printf("add_uint8 255+0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_255_ssa(0); got != 255 {
+ fmt.Printf("add_uint8 0+255 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := add_255_uint8_ssa(1); got != 0 {
+ fmt.Printf("add_uint8 255+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_255_ssa(1); got != 0 {
+ fmt.Printf("add_uint8 1+255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_255_uint8_ssa(255); got != 254 {
+ fmt.Printf("add_uint8 255+255 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := add_uint8_255_ssa(255); got != 254 {
+ fmt.Printf("add_uint8 255+255 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint8_ssa(0); got != 0 {
+ fmt.Printf("sub_uint8 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_0_ssa(0); got != 0 {
+ fmt.Printf("sub_uint8 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint8_ssa(1); got != 255 {
+ fmt.Printf("sub_uint8 0-1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_0_ssa(1); got != 1 {
+ fmt.Printf("sub_uint8 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_uint8_ssa(255); got != 1 {
+ fmt.Printf("sub_uint8 0-255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_0_ssa(255); got != 255 {
+ fmt.Printf("sub_uint8 255-0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint8_ssa(0); got != 1 {
+ fmt.Printf("sub_uint8 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_1_ssa(0); got != 255 {
+ fmt.Printf("sub_uint8 0-1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint8_ssa(1); got != 0 {
+ fmt.Printf("sub_uint8 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_1_ssa(1); got != 0 {
+ fmt.Printf("sub_uint8 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_uint8_ssa(255); got != 2 {
+ fmt.Printf("sub_uint8 1-255 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_1_ssa(255); got != 254 {
+ fmt.Printf("sub_uint8 255-1 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := sub_255_uint8_ssa(0); got != 255 {
+ fmt.Printf("sub_uint8 255-0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_255_ssa(0); got != 1 {
+ fmt.Printf("sub_uint8 0-255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_255_uint8_ssa(1); got != 254 {
+ fmt.Printf("sub_uint8 255-1 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_255_ssa(1); got != 2 {
+ fmt.Printf("sub_uint8 1-255 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_255_uint8_ssa(255); got != 0 {
+ fmt.Printf("sub_uint8 255-255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_uint8_255_ssa(255); got != 0 {
+ fmt.Printf("sub_uint8 255-255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint8_ssa(1); got != 0 {
+ fmt.Printf("div_uint8 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_uint8_ssa(255); got != 0 {
+ fmt.Printf("div_uint8 0/255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_1_ssa(0); got != 0 {
+ fmt.Printf("div_uint8 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint8_ssa(1); got != 1 {
+ fmt.Printf("div_uint8 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_1_ssa(1); got != 1 {
+ fmt.Printf("div_uint8 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_uint8_ssa(255); got != 0 {
+ fmt.Printf("div_uint8 1/255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_1_ssa(255); got != 255 {
+ fmt.Printf("div_uint8 255/1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_255_ssa(0); got != 0 {
+ fmt.Printf("div_uint8 0/255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_255_uint8_ssa(1); got != 255 {
+ fmt.Printf("div_uint8 255/1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_255_ssa(1); got != 0 {
+ fmt.Printf("div_uint8 1/255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_255_uint8_ssa(255); got != 1 {
+ fmt.Printf("div_uint8 255/255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_uint8_255_ssa(255); got != 1 {
+ fmt.Printf("div_uint8 255/255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint8_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_0_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint8_ssa(1); got != 0 {
+ fmt.Printf("mul_uint8 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_0_ssa(1); got != 0 {
+ fmt.Printf("mul_uint8 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_uint8_ssa(255); got != 0 {
+ fmt.Printf("mul_uint8 0*255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_0_ssa(255); got != 0 {
+ fmt.Printf("mul_uint8 255*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint8_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_1_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint8_ssa(1); got != 1 {
+ fmt.Printf("mul_uint8 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_1_ssa(1); got != 1 {
+ fmt.Printf("mul_uint8 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_uint8_ssa(255); got != 255 {
+ fmt.Printf("mul_uint8 1*255 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_1_ssa(255); got != 255 {
+ fmt.Printf("mul_uint8 255*1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := mul_255_uint8_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 255*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_255_ssa(0); got != 0 {
+ fmt.Printf("mul_uint8 0*255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_255_uint8_ssa(1); got != 255 {
+ fmt.Printf("mul_uint8 255*1 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_255_ssa(1); got != 255 {
+ fmt.Printf("mul_uint8 1*255 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := mul_255_uint8_ssa(255); got != 1 {
+ fmt.Printf("mul_uint8 255*255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_uint8_255_ssa(255); got != 1 {
+ fmt.Printf("mul_uint8 255*255 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint8_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint8 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_0_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint8 0<<0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint8_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint8 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_0_ssa(1); got != 1 {
+ fmt.Printf("lsh_uint8 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_0_uint8_ssa(255); got != 0 {
+ fmt.Printf("lsh_uint8 0<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_0_ssa(255); got != 255 {
+ fmt.Printf("lsh_uint8 255<<0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint8_ssa(0); got != 1 {
+ fmt.Printf("lsh_uint8 1<<0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_1_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint8 0<<1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint8_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint8 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_1_ssa(1); got != 2 {
+ fmt.Printf("lsh_uint8 1<<1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := lsh_1_uint8_ssa(255); got != 0 {
+ fmt.Printf("lsh_uint8 1<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_1_ssa(255); got != 254 {
+ fmt.Printf("lsh_uint8 255<<1 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := lsh_255_uint8_ssa(0); got != 255 {
+ fmt.Printf("lsh_uint8 255<<0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_255_ssa(0); got != 0 {
+ fmt.Printf("lsh_uint8 0<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_255_uint8_ssa(1); got != 254 {
+ fmt.Printf("lsh_uint8 255<<1 = %d, wanted 254\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_255_ssa(1); got != 0 {
+ fmt.Printf("lsh_uint8 1<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_255_uint8_ssa(255); got != 0 {
+ fmt.Printf("lsh_uint8 255<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := lsh_uint8_255_ssa(255); got != 0 {
+ fmt.Printf("lsh_uint8 255<<255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint8_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint8 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_0_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint8 0>>0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint8_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint8 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_0_ssa(1); got != 1 {
+ fmt.Printf("rsh_uint8 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_0_uint8_ssa(255); got != 0 {
+ fmt.Printf("rsh_uint8 0>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_0_ssa(255); got != 255 {
+ fmt.Printf("rsh_uint8 255>>0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint8_ssa(0); got != 1 {
+ fmt.Printf("rsh_uint8 1>>0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_1_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint8 0>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint8_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint8 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_1_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint8 1>>1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_1_uint8_ssa(255); got != 0 {
+ fmt.Printf("rsh_uint8 1>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_1_ssa(255); got != 127 {
+ fmt.Printf("rsh_uint8 255>>1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := rsh_255_uint8_ssa(0); got != 255 {
+ fmt.Printf("rsh_uint8 255>>0 = %d, wanted 255\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_255_ssa(0); got != 0 {
+ fmt.Printf("rsh_uint8 0>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_255_uint8_ssa(1); got != 127 {
+ fmt.Printf("rsh_uint8 255>>1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_255_ssa(1); got != 0 {
+ fmt.Printf("rsh_uint8 1>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_255_uint8_ssa(255); got != 0 {
+ fmt.Printf("rsh_uint8 255>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := rsh_uint8_255_ssa(255); got != 0 {
+ fmt.Printf("rsh_uint8 255>>255 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(-128); got != 0 {
+ fmt.Printf("add_int8 -128+-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(-128); got != 0 {
+ fmt.Printf("add_int8 -128+-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(-127); got != 1 {
+ fmt.Printf("add_int8 -128+-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(-127); got != 1 {
+ fmt.Printf("add_int8 -127+-128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(-1); got != 127 {
+ fmt.Printf("add_int8 -128+-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(-1); got != 127 {
+ fmt.Printf("add_int8 -1+-128 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(0); got != -128 {
+ fmt.Printf("add_int8 -128+0 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(0); got != -128 {
+ fmt.Printf("add_int8 0+-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(1); got != -127 {
+ fmt.Printf("add_int8 -128+1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(1); got != -127 {
+ fmt.Printf("add_int8 1+-128 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(126); got != -2 {
+ fmt.Printf("add_int8 -128+126 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(126); got != -2 {
+ fmt.Printf("add_int8 126+-128 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg128_int8_ssa(127); got != -1 {
+ fmt.Printf("add_int8 -128+127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg128_ssa(127); got != -1 {
+ fmt.Printf("add_int8 127+-128 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(-128); got != 1 {
+ fmt.Printf("add_int8 -127+-128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(-128); got != 1 {
+ fmt.Printf("add_int8 -128+-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(-127); got != 2 {
+ fmt.Printf("add_int8 -127+-127 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(-127); got != 2 {
+ fmt.Printf("add_int8 -127+-127 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(-1); got != -128 {
+ fmt.Printf("add_int8 -127+-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(-1); got != -128 {
+ fmt.Printf("add_int8 -1+-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(0); got != -127 {
+ fmt.Printf("add_int8 -127+0 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(0); got != -127 {
+ fmt.Printf("add_int8 0+-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(1); got != -126 {
+ fmt.Printf("add_int8 -127+1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(1); got != -126 {
+ fmt.Printf("add_int8 1+-127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(126); got != -1 {
+ fmt.Printf("add_int8 -127+126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(126); got != -1 {
+ fmt.Printf("add_int8 126+-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg127_int8_ssa(127); got != 0 {
+ fmt.Printf("add_int8 -127+127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg127_ssa(127); got != 0 {
+ fmt.Printf("add_int8 127+-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(-128); got != 127 {
+ fmt.Printf("add_int8 -1+-128 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(-128); got != 127 {
+ fmt.Printf("add_int8 -128+-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(-127); got != -128 {
+ fmt.Printf("add_int8 -1+-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(-127); got != -128 {
+ fmt.Printf("add_int8 -127+-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(-1); got != -2 {
+ fmt.Printf("add_int8 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(-1); got != -2 {
+ fmt.Printf("add_int8 -1+-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(0); got != -1 {
+ fmt.Printf("add_int8 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(0); got != -1 {
+ fmt.Printf("add_int8 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(1); got != 0 {
+ fmt.Printf("add_int8 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(1); got != 0 {
+ fmt.Printf("add_int8 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(126); got != 125 {
+ fmt.Printf("add_int8 -1+126 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(126); got != 125 {
+ fmt.Printf("add_int8 126+-1 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := add_Neg1_int8_ssa(127); got != 126 {
+ fmt.Printf("add_int8 -1+127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_Neg1_ssa(127); got != 126 {
+ fmt.Printf("add_int8 127+-1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(-128); got != -128 {
+ fmt.Printf("add_int8 0+-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(-128); got != -128 {
+ fmt.Printf("add_int8 -128+0 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(-127); got != -127 {
+ fmt.Printf("add_int8 0+-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(-127); got != -127 {
+ fmt.Printf("add_int8 -127+0 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(-1); got != -1 {
+ fmt.Printf("add_int8 0+-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(-1); got != -1 {
+ fmt.Printf("add_int8 -1+0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(0); got != 0 {
+ fmt.Printf("add_int8 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(0); got != 0 {
+ fmt.Printf("add_int8 0+0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(1); got != 1 {
+ fmt.Printf("add_int8 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(1); got != 1 {
+ fmt.Printf("add_int8 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(126); got != 126 {
+ fmt.Printf("add_int8 0+126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(126); got != 126 {
+ fmt.Printf("add_int8 126+0 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_0_int8_ssa(127); got != 127 {
+ fmt.Printf("add_int8 0+127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_0_ssa(127); got != 127 {
+ fmt.Printf("add_int8 127+0 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(-128); got != -127 {
+ fmt.Printf("add_int8 1+-128 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(-128); got != -127 {
+ fmt.Printf("add_int8 -128+1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(-127); got != -126 {
+ fmt.Printf("add_int8 1+-127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(-127); got != -126 {
+ fmt.Printf("add_int8 -127+1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(-1); got != 0 {
+ fmt.Printf("add_int8 1+-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(-1); got != 0 {
+ fmt.Printf("add_int8 -1+1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(0); got != 1 {
+ fmt.Printf("add_int8 1+0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(0); got != 1 {
+ fmt.Printf("add_int8 0+1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(1); got != 2 {
+ fmt.Printf("add_int8 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(1); got != 2 {
+ fmt.Printf("add_int8 1+1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(126); got != 127 {
+ fmt.Printf("add_int8 1+126 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(126); got != 127 {
+ fmt.Printf("add_int8 126+1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_1_int8_ssa(127); got != -128 {
+ fmt.Printf("add_int8 1+127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_1_ssa(127); got != -128 {
+ fmt.Printf("add_int8 127+1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(-128); got != -2 {
+ fmt.Printf("add_int8 126+-128 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(-128); got != -2 {
+ fmt.Printf("add_int8 -128+126 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(-127); got != -1 {
+ fmt.Printf("add_int8 126+-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(-127); got != -1 {
+ fmt.Printf("add_int8 -127+126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(-1); got != 125 {
+ fmt.Printf("add_int8 126+-1 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(-1); got != 125 {
+ fmt.Printf("add_int8 -1+126 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(0); got != 126 {
+ fmt.Printf("add_int8 126+0 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(0); got != 126 {
+ fmt.Printf("add_int8 0+126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(1); got != 127 {
+ fmt.Printf("add_int8 126+1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(1); got != 127 {
+ fmt.Printf("add_int8 1+126 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(126); got != -4 {
+ fmt.Printf("add_int8 126+126 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(126); got != -4 {
+ fmt.Printf("add_int8 126+126 = %d, wanted -4\n", got)
+ failed = true
+ }
+
+ if got := add_126_int8_ssa(127); got != -3 {
+ fmt.Printf("add_int8 126+127 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int8_126_ssa(127); got != -3 {
+ fmt.Printf("add_int8 127+126 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(-128); got != -1 {
+ fmt.Printf("add_int8 127+-128 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(-128); got != -1 {
+ fmt.Printf("add_int8 -128+127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(-127); got != 0 {
+ fmt.Printf("add_int8 127+-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(-127); got != 0 {
+ fmt.Printf("add_int8 -127+127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(-1); got != 126 {
+ fmt.Printf("add_int8 127+-1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(-1); got != 126 {
+ fmt.Printf("add_int8 -1+127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(0); got != 127 {
+ fmt.Printf("add_int8 127+0 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(0); got != 127 {
+ fmt.Printf("add_int8 0+127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(1); got != -128 {
+ fmt.Printf("add_int8 127+1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(1); got != -128 {
+ fmt.Printf("add_int8 1+127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(126); got != -3 {
+ fmt.Printf("add_int8 127+126 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(126); got != -3 {
+ fmt.Printf("add_int8 126+127 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := add_127_int8_ssa(127); got != -2 {
+ fmt.Printf("add_int8 127+127 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := add_int8_127_ssa(127); got != -2 {
+ fmt.Printf("add_int8 127+127 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(-128); got != 0 {
+ fmt.Printf("sub_int8 -128--128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(-128); got != 0 {
+ fmt.Printf("sub_int8 -128--128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(-127); got != -1 {
+ fmt.Printf("sub_int8 -128--127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(-127); got != 1 {
+ fmt.Printf("sub_int8 -127--128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(-1); got != -127 {
+ fmt.Printf("sub_int8 -128--1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(-1); got != 127 {
+ fmt.Printf("sub_int8 -1--128 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(0); got != -128 {
+ fmt.Printf("sub_int8 -128-0 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(0); got != -128 {
+ fmt.Printf("sub_int8 0--128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(1); got != 127 {
+ fmt.Printf("sub_int8 -128-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(1); got != -127 {
+ fmt.Printf("sub_int8 1--128 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(126); got != 2 {
+ fmt.Printf("sub_int8 -128-126 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(126); got != -2 {
+ fmt.Printf("sub_int8 126--128 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg128_int8_ssa(127); got != 1 {
+ fmt.Printf("sub_int8 -128-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg128_ssa(127); got != -1 {
+ fmt.Printf("sub_int8 127--128 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(-128); got != 1 {
+ fmt.Printf("sub_int8 -127--128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(-128); got != -1 {
+ fmt.Printf("sub_int8 -128--127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(-127); got != 0 {
+ fmt.Printf("sub_int8 -127--127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(-127); got != 0 {
+ fmt.Printf("sub_int8 -127--127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(-1); got != -126 {
+ fmt.Printf("sub_int8 -127--1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(-1); got != 126 {
+ fmt.Printf("sub_int8 -1--127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(0); got != -127 {
+ fmt.Printf("sub_int8 -127-0 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(0); got != 127 {
+ fmt.Printf("sub_int8 0--127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(1); got != -128 {
+ fmt.Printf("sub_int8 -127-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(1); got != -128 {
+ fmt.Printf("sub_int8 1--127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(126); got != 3 {
+ fmt.Printf("sub_int8 -127-126 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(126); got != -3 {
+ fmt.Printf("sub_int8 126--127 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg127_int8_ssa(127); got != 2 {
+ fmt.Printf("sub_int8 -127-127 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg127_ssa(127); got != -2 {
+ fmt.Printf("sub_int8 127--127 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(-128); got != 127 {
+ fmt.Printf("sub_int8 -1--128 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(-128); got != -127 {
+ fmt.Printf("sub_int8 -128--1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(-127); got != 126 {
+ fmt.Printf("sub_int8 -1--127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(-127); got != -126 {
+ fmt.Printf("sub_int8 -127--1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(-1); got != 0 {
+ fmt.Printf("sub_int8 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(-1); got != 0 {
+ fmt.Printf("sub_int8 -1--1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(0); got != -1 {
+ fmt.Printf("sub_int8 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(0); got != 1 {
+ fmt.Printf("sub_int8 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(1); got != -2 {
+ fmt.Printf("sub_int8 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(1); got != 2 {
+ fmt.Printf("sub_int8 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(126); got != -127 {
+ fmt.Printf("sub_int8 -1-126 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(126); got != 127 {
+ fmt.Printf("sub_int8 126--1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_Neg1_int8_ssa(127); got != -128 {
+ fmt.Printf("sub_int8 -1-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_Neg1_ssa(127); got != -128 {
+ fmt.Printf("sub_int8 127--1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(-128); got != -128 {
+ fmt.Printf("sub_int8 0--128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(-128); got != -128 {
+ fmt.Printf("sub_int8 -128-0 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(-127); got != 127 {
+ fmt.Printf("sub_int8 0--127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(-127); got != -127 {
+ fmt.Printf("sub_int8 -127-0 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(-1); got != 1 {
+ fmt.Printf("sub_int8 0--1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(-1); got != -1 {
+ fmt.Printf("sub_int8 -1-0 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(0); got != 0 {
+ fmt.Printf("sub_int8 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(0); got != 0 {
+ fmt.Printf("sub_int8 0-0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(1); got != -1 {
+ fmt.Printf("sub_int8 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(1); got != 1 {
+ fmt.Printf("sub_int8 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(126); got != -126 {
+ fmt.Printf("sub_int8 0-126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(126); got != 126 {
+ fmt.Printf("sub_int8 126-0 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_0_int8_ssa(127); got != -127 {
+ fmt.Printf("sub_int8 0-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_0_ssa(127); got != 127 {
+ fmt.Printf("sub_int8 127-0 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(-128); got != -127 {
+ fmt.Printf("sub_int8 1--128 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(-128); got != 127 {
+ fmt.Printf("sub_int8 -128-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(-127); got != -128 {
+ fmt.Printf("sub_int8 1--127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(-127); got != -128 {
+ fmt.Printf("sub_int8 -127-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(-1); got != 2 {
+ fmt.Printf("sub_int8 1--1 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(-1); got != -2 {
+ fmt.Printf("sub_int8 -1-1 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(0); got != 1 {
+ fmt.Printf("sub_int8 1-0 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(0); got != -1 {
+ fmt.Printf("sub_int8 0-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(1); got != 0 {
+ fmt.Printf("sub_int8 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(1); got != 0 {
+ fmt.Printf("sub_int8 1-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(126); got != -125 {
+ fmt.Printf("sub_int8 1-126 = %d, wanted -125\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(126); got != 125 {
+ fmt.Printf("sub_int8 126-1 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := sub_1_int8_ssa(127); got != -126 {
+ fmt.Printf("sub_int8 1-127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_1_ssa(127); got != 126 {
+ fmt.Printf("sub_int8 127-1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(-128); got != -2 {
+ fmt.Printf("sub_int8 126--128 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(-128); got != 2 {
+ fmt.Printf("sub_int8 -128-126 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(-127); got != -3 {
+ fmt.Printf("sub_int8 126--127 = %d, wanted -3\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(-127); got != 3 {
+ fmt.Printf("sub_int8 -127-126 = %d, wanted 3\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(-1); got != 127 {
+ fmt.Printf("sub_int8 126--1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(-1); got != -127 {
+ fmt.Printf("sub_int8 -1-126 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(0); got != 126 {
+ fmt.Printf("sub_int8 126-0 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(0); got != -126 {
+ fmt.Printf("sub_int8 0-126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(1); got != 125 {
+ fmt.Printf("sub_int8 126-1 = %d, wanted 125\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(1); got != -125 {
+ fmt.Printf("sub_int8 1-126 = %d, wanted -125\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(126); got != 0 {
+ fmt.Printf("sub_int8 126-126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(126); got != 0 {
+ fmt.Printf("sub_int8 126-126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_126_int8_ssa(127); got != -1 {
+ fmt.Printf("sub_int8 126-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_126_ssa(127); got != 1 {
+ fmt.Printf("sub_int8 127-126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(-128); got != -1 {
+ fmt.Printf("sub_int8 127--128 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(-128); got != 1 {
+ fmt.Printf("sub_int8 -128-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(-127); got != -2 {
+ fmt.Printf("sub_int8 127--127 = %d, wanted -2\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(-127); got != 2 {
+ fmt.Printf("sub_int8 -127-127 = %d, wanted 2\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(-1); got != -128 {
+ fmt.Printf("sub_int8 127--1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(-1); got != -128 {
+ fmt.Printf("sub_int8 -1-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(0); got != 127 {
+ fmt.Printf("sub_int8 127-0 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(0); got != -127 {
+ fmt.Printf("sub_int8 0-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(1); got != 126 {
+ fmt.Printf("sub_int8 127-1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(1); got != -126 {
+ fmt.Printf("sub_int8 1-127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(126); got != 1 {
+ fmt.Printf("sub_int8 127-126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(126); got != -1 {
+ fmt.Printf("sub_int8 126-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := sub_127_int8_ssa(127); got != 0 {
+ fmt.Printf("sub_int8 127-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := sub_int8_127_ssa(127); got != 0 {
+ fmt.Printf("sub_int8 127-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(-128); got != 1 {
+ fmt.Printf("div_int8 -128/-128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(-128); got != 1 {
+ fmt.Printf("div_int8 -128/-128 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(-127); got != 1 {
+ fmt.Printf("div_int8 -128/-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(-127); got != 0 {
+ fmt.Printf("div_int8 -127/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(-1); got != -128 {
+ fmt.Printf("div_int8 -128/-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(-1); got != 0 {
+ fmt.Printf("div_int8 -1/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(1); got != -128 {
+ fmt.Printf("div_int8 -128/1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(1); got != 0 {
+ fmt.Printf("div_int8 1/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(126); got != -1 {
+ fmt.Printf("div_int8 -128/126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(126); got != 0 {
+ fmt.Printf("div_int8 126/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg128_int8_ssa(127); got != -1 {
+ fmt.Printf("div_int8 -128/127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg128_ssa(127); got != 0 {
+ fmt.Printf("div_int8 127/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 -127/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(-128); got != 1 {
+ fmt.Printf("div_int8 -128/-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(-127); got != 1 {
+ fmt.Printf("div_int8 -127/-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(-127); got != 1 {
+ fmt.Printf("div_int8 -127/-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(-1); got != 127 {
+ fmt.Printf("div_int8 -127/-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(-1); got != 0 {
+ fmt.Printf("div_int8 -1/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(1); got != -127 {
+ fmt.Printf("div_int8 -127/1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(1); got != 0 {
+ fmt.Printf("div_int8 1/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(126); got != -1 {
+ fmt.Printf("div_int8 -127/126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(126); got != 0 {
+ fmt.Printf("div_int8 126/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg127_int8_ssa(127); got != -1 {
+ fmt.Printf("div_int8 -127/127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg127_ssa(127); got != -1 {
+ fmt.Printf("div_int8 127/-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 -1/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(-128); got != -128 {
+ fmt.Printf("div_int8 -128/-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(-127); got != 0 {
+ fmt.Printf("div_int8 -1/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(-127); got != 127 {
+ fmt.Printf("div_int8 -127/-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(-1); got != 1 {
+ fmt.Printf("div_int8 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("div_int8 -1/-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(1); got != -1 {
+ fmt.Printf("div_int8 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(1); got != -1 {
+ fmt.Printf("div_int8 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(126); got != 0 {
+ fmt.Printf("div_int8 -1/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(126); got != -126 {
+ fmt.Printf("div_int8 126/-1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := div_Neg1_int8_ssa(127); got != 0 {
+ fmt.Printf("div_int8 -1/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_Neg1_ssa(127); got != -127 {
+ fmt.Printf("div_int8 127/-1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 0/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(-127); got != 0 {
+ fmt.Printf("div_int8 0/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(-1); got != 0 {
+ fmt.Printf("div_int8 0/-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(1); got != 0 {
+ fmt.Printf("div_int8 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(126); got != 0 {
+ fmt.Printf("div_int8 0/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_0_int8_ssa(127); got != 0 {
+ fmt.Printf("div_int8 0/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 1/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(-128); got != -128 {
+ fmt.Printf("div_int8 -128/1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(-127); got != 0 {
+ fmt.Printf("div_int8 1/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(-127); got != -127 {
+ fmt.Printf("div_int8 -127/1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(-1); got != -1 {
+ fmt.Printf("div_int8 1/-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(-1); got != -1 {
+ fmt.Printf("div_int8 -1/1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(1); got != 1 {
+ fmt.Printf("div_int8 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(1); got != 1 {
+ fmt.Printf("div_int8 1/1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(126); got != 0 {
+ fmt.Printf("div_int8 1/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(126); got != 126 {
+ fmt.Printf("div_int8 126/1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := div_1_int8_ssa(127); got != 0 {
+ fmt.Printf("div_int8 1/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_1_ssa(127); got != 127 {
+ fmt.Printf("div_int8 127/1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 126/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(-128); got != -1 {
+ fmt.Printf("div_int8 -128/126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(-127); got != 0 {
+ fmt.Printf("div_int8 126/-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(-127); got != -1 {
+ fmt.Printf("div_int8 -127/126 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(-1); got != -126 {
+ fmt.Printf("div_int8 126/-1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(-1); got != 0 {
+ fmt.Printf("div_int8 -1/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(1); got != 126 {
+ fmt.Printf("div_int8 126/1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(1); got != 0 {
+ fmt.Printf("div_int8 1/126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(126); got != 1 {
+ fmt.Printf("div_int8 126/126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(126); got != 1 {
+ fmt.Printf("div_int8 126/126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_126_int8_ssa(127); got != 0 {
+ fmt.Printf("div_int8 126/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_126_ssa(127); got != 1 {
+ fmt.Printf("div_int8 127/126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(-128); got != 0 {
+ fmt.Printf("div_int8 127/-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(-128); got != -1 {
+ fmt.Printf("div_int8 -128/127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(-127); got != -1 {
+ fmt.Printf("div_int8 127/-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(-127); got != -1 {
+ fmt.Printf("div_int8 -127/127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(-1); got != -127 {
+ fmt.Printf("div_int8 127/-1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(-1); got != 0 {
+ fmt.Printf("div_int8 -1/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(0); got != 0 {
+ fmt.Printf("div_int8 0/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(1); got != 127 {
+ fmt.Printf("div_int8 127/1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(1); got != 0 {
+ fmt.Printf("div_int8 1/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(126); got != 1 {
+ fmt.Printf("div_int8 127/126 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(126); got != 0 {
+ fmt.Printf("div_int8 126/127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := div_127_int8_ssa(127); got != 1 {
+ fmt.Printf("div_int8 127/127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := div_int8_127_ssa(127); got != 1 {
+ fmt.Printf("div_int8 127/127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 -128*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 -128*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(-127); got != -128 {
+ fmt.Printf("mul_int8 -128*-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(-127); got != -128 {
+ fmt.Printf("mul_int8 -127*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(-1); got != -128 {
+ fmt.Printf("mul_int8 -128*-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(-1); got != -128 {
+ fmt.Printf("mul_int8 -1*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 -128*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(1); got != -128 {
+ fmt.Printf("mul_int8 -128*1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(1); got != -128 {
+ fmt.Printf("mul_int8 1*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(126); got != 0 {
+ fmt.Printf("mul_int8 -128*126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(126); got != 0 {
+ fmt.Printf("mul_int8 126*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg128_int8_ssa(127); got != -128 {
+ fmt.Printf("mul_int8 -128*127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg128_ssa(127); got != -128 {
+ fmt.Printf("mul_int8 127*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -127*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -128*-127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(-127); got != 1 {
+ fmt.Printf("mul_int8 -127*-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(-127); got != 1 {
+ fmt.Printf("mul_int8 -127*-127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(-1); got != 127 {
+ fmt.Printf("mul_int8 -127*-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(-1); got != 127 {
+ fmt.Printf("mul_int8 -1*-127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 -127*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(1); got != -127 {
+ fmt.Printf("mul_int8 -127*1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(1); got != -127 {
+ fmt.Printf("mul_int8 1*-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(126); got != 126 {
+ fmt.Printf("mul_int8 -127*126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(126); got != 126 {
+ fmt.Printf("mul_int8 126*-127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg127_int8_ssa(127); got != -1 {
+ fmt.Printf("mul_int8 -127*127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg127_ssa(127); got != -1 {
+ fmt.Printf("mul_int8 127*-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -1*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -128*-1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(-127); got != 127 {
+ fmt.Printf("mul_int8 -1*-127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(-127); got != 127 {
+ fmt.Printf("mul_int8 -127*-1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(-1); got != 1 {
+ fmt.Printf("mul_int8 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(-1); got != 1 {
+ fmt.Printf("mul_int8 -1*-1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(1); got != -1 {
+ fmt.Printf("mul_int8 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(1); got != -1 {
+ fmt.Printf("mul_int8 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(126); got != -126 {
+ fmt.Printf("mul_int8 -1*126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(126); got != -126 {
+ fmt.Printf("mul_int8 126*-1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_Neg1_int8_ssa(127); got != -127 {
+ fmt.Printf("mul_int8 -1*127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_Neg1_ssa(127); got != -127 {
+ fmt.Printf("mul_int8 127*-1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 0*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 -128*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(-127); got != 0 {
+ fmt.Printf("mul_int8 0*-127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(-127); got != 0 {
+ fmt.Printf("mul_int8 -127*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(-1); got != 0 {
+ fmt.Printf("mul_int8 0*-1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(-1); got != 0 {
+ fmt.Printf("mul_int8 -1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(1); got != 0 {
+ fmt.Printf("mul_int8 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(1); got != 0 {
+ fmt.Printf("mul_int8 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(126); got != 0 {
+ fmt.Printf("mul_int8 0*126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(126); got != 0 {
+ fmt.Printf("mul_int8 126*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_0_int8_ssa(127); got != 0 {
+ fmt.Printf("mul_int8 0*127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_0_ssa(127); got != 0 {
+ fmt.Printf("mul_int8 127*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 1*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -128*1 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(-127); got != -127 {
+ fmt.Printf("mul_int8 1*-127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(-127); got != -127 {
+ fmt.Printf("mul_int8 -127*1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(-1); got != -1 {
+ fmt.Printf("mul_int8 1*-1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(-1); got != -1 {
+ fmt.Printf("mul_int8 -1*1 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 1*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*1 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(1); got != 1 {
+ fmt.Printf("mul_int8 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(1); got != 1 {
+ fmt.Printf("mul_int8 1*1 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(126); got != 126 {
+ fmt.Printf("mul_int8 1*126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(126); got != 126 {
+ fmt.Printf("mul_int8 126*1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_1_int8_ssa(127); got != 127 {
+ fmt.Printf("mul_int8 1*127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_1_ssa(127); got != 127 {
+ fmt.Printf("mul_int8 127*1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 126*-128 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(-128); got != 0 {
+ fmt.Printf("mul_int8 -128*126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(-127); got != 126 {
+ fmt.Printf("mul_int8 126*-127 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(-127); got != 126 {
+ fmt.Printf("mul_int8 -127*126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(-1); got != -126 {
+ fmt.Printf("mul_int8 126*-1 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(-1); got != -126 {
+ fmt.Printf("mul_int8 -1*126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 126*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*126 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(1); got != 126 {
+ fmt.Printf("mul_int8 126*1 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(1); got != 126 {
+ fmt.Printf("mul_int8 1*126 = %d, wanted 126\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(126); got != 4 {
+ fmt.Printf("mul_int8 126*126 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(126); got != 4 {
+ fmt.Printf("mul_int8 126*126 = %d, wanted 4\n", got)
+ failed = true
+ }
+
+ if got := mul_126_int8_ssa(127); got != -126 {
+ fmt.Printf("mul_int8 126*127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_126_ssa(127); got != -126 {
+ fmt.Printf("mul_int8 127*126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 127*-128 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(-128); got != -128 {
+ fmt.Printf("mul_int8 -128*127 = %d, wanted -128\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(-127); got != -1 {
+ fmt.Printf("mul_int8 127*-127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(-127); got != -1 {
+ fmt.Printf("mul_int8 -127*127 = %d, wanted -1\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(-1); got != -127 {
+ fmt.Printf("mul_int8 127*-1 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(-1); got != -127 {
+ fmt.Printf("mul_int8 -1*127 = %d, wanted -127\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 127*0 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(0); got != 0 {
+ fmt.Printf("mul_int8 0*127 = %d, wanted 0\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(1); got != 127 {
+ fmt.Printf("mul_int8 127*1 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(1); got != 127 {
+ fmt.Printf("mul_int8 1*127 = %d, wanted 127\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(126); got != -126 {
+ fmt.Printf("mul_int8 127*126 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(126); got != -126 {
+ fmt.Printf("mul_int8 126*127 = %d, wanted -126\n", got)
+ failed = true
+ }
+
+ if got := mul_127_int8_ssa(127); got != 1 {
+ fmt.Printf("mul_int8 127*127 = %d, wanted 1\n", got)
+ failed = true
+ }
+
+ if got := mul_int8_127_ssa(127); got != 1 {
+ fmt.Printf("mul_int8 127*127 = %d, wanted 1\n", got)
+ failed = true
+ }
+ if failed {
+ panic("tests failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go
new file mode 100644
index 0000000..f4bea0e
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go
@@ -0,0 +1,438 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests arithmetic expressions
+
+package main
+
+import "fmt"
+
+const (
+ y = 0x0fffFFFF
+)
+
+//go:noinline
+func invalidAdd_ssa(x uint32) uint32 {
+ return x + y + y + y + y + y + y + y + y + y + y + y + y + y + y + y + y + y
+}
+
+//go:noinline
+func invalidSub_ssa(x uint32) uint32 {
+ return x - y - y - y - y - y - y - y - y - y - y - y - y - y - y - y - y - y
+}
+
+//go:noinline
+func invalidMul_ssa(x uint32) uint32 {
+ return x * y * y * y * y * y * y * y * y * y * y * y * y * y * y * y * y * y
+}
+
+// testLargeConst tests a situation where larger than 32 bit consts were passed to ADDL
+// causing an invalid instruction error.
+func testLargeConst() {
+ if want, got := uint32(268435440), invalidAdd_ssa(1); want != got {
+ println("testLargeConst add failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(4026531858), invalidSub_ssa(1); want != got {
+ println("testLargeConst sub failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(268435455), invalidMul_ssa(1); want != got {
+ println("testLargeConst mul failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+// testArithRshConst ensures that "const >> const" right shifts correctly perform
+// sign extension on the lhs constant
+func testArithRshConst() {
+ wantu := uint64(0x4000000000000000)
+ if got := arithRshuConst_ssa(); got != wantu {
+ println("arithRshuConst failed, wanted", wantu, "got", got)
+ failed = true
+ }
+
+ wants := int64(-0x4000000000000000)
+ if got := arithRshConst_ssa(); got != wants {
+ println("arithRshuConst failed, wanted", wants, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func arithRshuConst_ssa() uint64 {
+ y := uint64(0x8000000000000001)
+ z := uint64(1)
+ return uint64(y >> z)
+}
+
+//go:noinline
+func arithRshConst_ssa() int64 {
+ y := int64(-0x8000000000000000)
+ z := uint64(1)
+ return int64(y >> z)
+}
+
+//go:noinline
+func arithConstShift_ssa(x int64) int64 {
+ return x >> 100
+}
+
+// testArithConstShift tests that right shift by large constants preserve
+// the sign of the input.
+func testArithConstShift() {
+ want := int64(-1)
+ if got := arithConstShift_ssa(-1); want != got {
+ println("arithConstShift_ssa(-1) failed, wanted", want, "got", got)
+ failed = true
+ }
+ want = 0
+ if got := arithConstShift_ssa(1); want != got {
+ println("arithConstShift_ssa(1) failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+// overflowConstShift_ssa verifes that constant folding for shift
+// doesn't wrap (i.e. x << MAX_INT << 1 doesn't get folded to x << 0).
+//go:noinline
+func overflowConstShift64_ssa(x int64) int64 {
+ return x << uint64(0xffffffffffffffff) << uint64(1)
+}
+
+//go:noinline
+func overflowConstShift32_ssa(x int64) int32 {
+ return int32(x) << uint32(0xffffffff) << uint32(1)
+}
+
+//go:noinline
+func overflowConstShift16_ssa(x int64) int16 {
+ return int16(x) << uint16(0xffff) << uint16(1)
+}
+
+//go:noinline
+func overflowConstShift8_ssa(x int64) int8 {
+ return int8(x) << uint8(0xff) << uint8(1)
+}
+
+func testOverflowConstShift() {
+ want := int64(0)
+ for x := int64(-127); x < int64(127); x++ {
+ got := overflowConstShift64_ssa(x)
+ if want != got {
+ fmt.Printf("overflowShift64 failed, wanted %d got %d\n", want, got)
+ }
+ got = int64(overflowConstShift32_ssa(x))
+ if want != got {
+ fmt.Printf("overflowShift32 failed, wanted %d got %d\n", want, got)
+ }
+ got = int64(overflowConstShift16_ssa(x))
+ if want != got {
+ fmt.Printf("overflowShift16 failed, wanted %d got %d\n", want, got)
+ }
+ got = int64(overflowConstShift8_ssa(x))
+ if want != got {
+ fmt.Printf("overflowShift8 failed, wanted %d got %d\n", want, got)
+ }
+ }
+}
+
+// test64BitConstMult tests that rewrite rules don't fold 64 bit constants
+// into multiply instructions.
+func test64BitConstMult() {
+ want := int64(103079215109)
+ if got := test64BitConstMult_ssa(1, 2); want != got {
+ println("test64BitConstMult failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func test64BitConstMult_ssa(a, b int64) int64 {
+ return 34359738369*a + b*34359738370
+}
+
+// test64BitConstAdd tests that rewrite rules don't fold 64 bit constants
+// into add instructions.
+func test64BitConstAdd() {
+ want := int64(3567671782835376650)
+ if got := test64BitConstAdd_ssa(1, 2); want != got {
+ println("test64BitConstAdd failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func test64BitConstAdd_ssa(a, b int64) int64 {
+ return a + 575815584948629622 + b + 2991856197886747025
+}
+
+// testRegallocCVSpill tests that regalloc spills a value whose last use is the
+// current value.
+func testRegallocCVSpill() {
+ want := int8(-9)
+ if got := testRegallocCVSpill_ssa(1, 2, 3, 4); want != got {
+ println("testRegallocCVSpill failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func testRegallocCVSpill_ssa(a, b, c, d int8) int8 {
+ return a + -32 + b + 63*c*-87*d
+}
+
+func testBitwiseLogic() {
+ a, b := uint32(57623283), uint32(1314713839)
+ if want, got := uint32(38551779), testBitwiseAnd_ssa(a, b); want != got {
+ println("testBitwiseAnd failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(1333785343), testBitwiseOr_ssa(a, b); want != got {
+ println("testBitwiseOr failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(1295233564), testBitwiseXor_ssa(a, b); want != got {
+ println("testBitwiseXor failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(832), testBitwiseLsh_ssa(13, 4, 2); want != got {
+ println("testBitwiseLsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(0), testBitwiseLsh_ssa(13, 25, 15); want != got {
+ println("testBitwiseLsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(0), testBitwiseLsh_ssa(-13, 25, 15); want != got {
+ println("testBitwiseLsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(-13), testBitwiseRsh_ssa(-832, 4, 2); want != got {
+ println("testBitwiseRsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(0), testBitwiseRsh_ssa(13, 25, 15); want != got {
+ println("testBitwiseRsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := int32(-1), testBitwiseRsh_ssa(-13, 25, 15); want != got {
+ println("testBitwiseRsh failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(0x3ffffff), testBitwiseRshU_ssa(0xffffffff, 4, 2); want != got {
+ println("testBitwiseRshU failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(0), testBitwiseRshU_ssa(13, 25, 15); want != got {
+ println("testBitwiseRshU failed, wanted", want, "got", got)
+ failed = true
+ }
+ if want, got := uint32(0), testBitwiseRshU_ssa(0x8aaaaaaa, 25, 15); want != got {
+ println("testBitwiseRshU failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func testBitwiseAnd_ssa(a, b uint32) uint32 {
+ return a & b
+}
+
+//go:noinline
+func testBitwiseOr_ssa(a, b uint32) uint32 {
+ return a | b
+}
+
+//go:noinline
+func testBitwiseXor_ssa(a, b uint32) uint32 {
+ return a ^ b
+}
+
+//go:noinline
+func testBitwiseLsh_ssa(a int32, b, c uint32) int32 {
+ return a << b << c
+}
+
+//go:noinline
+func testBitwiseRsh_ssa(a int32, b, c uint32) int32 {
+ return a >> b >> c
+}
+
+//go:noinline
+func testBitwiseRshU_ssa(a uint32, b, c uint32) uint32 {
+ return a >> b >> c
+}
+
+//go:noinline
+func testShiftCX_ssa() int {
+ v1 := uint8(3)
+ v4 := (v1 * v1) ^ v1 | v1 - v1 - v1&v1 ^ uint8(3+2) + v1*1>>0 - v1 | 1 | v1<<(2*3|0-0*0^1)
+ v5 := v4>>(3-0-uint(3)) | v1 | v1 + v1 ^ v4<<(0+1|3&1)<<(uint64(1)<<0*2*0<<0) ^ v1
+ v6 := v5 ^ (v1+v1)*v1 | v1 | v1*v1>>(v1&v1)>>(uint(1)<<0*uint(3)>>1)*v1<<2*v1<<v1 - v1>>2 | (v4 - v1) ^ v1 + v1 ^ v1>>1 | v1 + v1 - v1 ^ v1
+ v7 := v6 & v5 << 0
+ v1++
+ v11 := 2&1 ^ 0 + 3 | int(0^0)<<1>>(1*0*3) ^ 0*0 ^ 3&0*3&3 ^ 3*3 ^ 1 ^ int(2)<<(2*3) + 2 | 2 | 2 ^ 2 + 1 | 3 | 0 ^ int(1)>>1 ^ 2 // int
+ v7--
+ return int(uint64(2*1)<<(3-2)<<uint(3>>v7)-2)&v11 | v11 - int(2)<<0>>(2-1)*(v11*0&v11<<1<<(uint8(2)+v4))
+}
+
+func testShiftCX() {
+ want := 141
+ if got := testShiftCX_ssa(); want != got {
+ println("testShiftCX failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+// testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly.
+func testSubqToNegq() {
+ want := int64(-318294940372190156)
+ if got := testSubqToNegq_ssa(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2); want != got {
+ println("testSubqToNegq failed, wanted", want, "got", got)
+ failed = true
+ }
+}
+
+//go:noinline
+func testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k int64) int64 {
+ return a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479
+}
+
+func testOcom() {
+ want1, want2 := int32(0x55555555), int32(-0x55555556)
+ if got1, got2 := testOcom_ssa(0x55555555, 0x55555555); want1 != got1 || want2 != got2 {
+ println("testSubqToNegq failed, wanted", want1, "and", want2,
+ "got", got1, "and", got2)
+ failed = true
+ }
+}
+
+//go:noinline
+func testOcom_ssa(a, b int32) (int32, int32) {
+ return ^^^^a, ^^^^^b
+}
+
+func lrot1_ssa(w uint8, x uint16, y uint32, z uint64) (a uint8, b uint16, c uint32, d uint64) {
+ a = (w << 5) | (w >> 3)
+ b = (x << 13) | (x >> 3)
+ c = (y << 29) | (y >> 3)
+ d = (z << 61) | (z >> 3)
+ return
+}
+
+//go:noinline
+func lrot2_ssa(w, n uint32) uint32 {
+ // Want to be sure that a "rotate by 32" which
+ // is really 0 | (w >> 0) == w
+ // is correctly compiled.
+ return (w << n) | (w >> (32 - n))
+}
+
+//go:noinline
+func lrot3_ssa(w uint32) uint32 {
+ // Want to be sure that a "rotate by 32" which
+ // is really 0 | (w >> 0) == w
+ // is correctly compiled.
+ return (w << 32) | (w >> (32 - 32))
+}
+
+func testLrot() {
+ wantA, wantB, wantC, wantD := uint8(0xe1), uint16(0xe001),
+ uint32(0xe0000001), uint64(0xe000000000000001)
+ a, b, c, d := lrot1_ssa(0xf, 0xf, 0xf, 0xf)
+ if a != wantA || b != wantB || c != wantC || d != wantD {
+ println("lrot1_ssa(0xf, 0xf, 0xf, 0xf)=",
+ wantA, wantB, wantC, wantD, ", got", a, b, c, d)
+ failed = true
+ }
+ x := lrot2_ssa(0xb0000001, 32)
+ wantX := uint32(0xb0000001)
+ if x != wantX {
+ println("lrot2_ssa(0xb0000001, 32)=",
+ wantX, ", got", x)
+ failed = true
+ }
+ x = lrot3_ssa(0xb0000001)
+ if x != wantX {
+ println("lrot3_ssa(0xb0000001)=",
+ wantX, ", got", x)
+ failed = true
+ }
+
+}
+
+//go:noinline
+func sub1_ssa() uint64 {
+ v1 := uint64(3) // uint64
+ return v1*v1 - (v1&v1)&v1
+}
+func sub2_ssa() uint8 {
+ switch {
+ }
+ v1 := uint8(0)
+ v3 := v1 + v1 + v1 ^ v1 | 3 + v1 ^ v1 | v1 ^ v1
+ v1-- // dev.ssa doesn't see this one
+ return v1 ^ v1*v1 - v3
+}
+
+func testSubConst() {
+ x1 := sub1_ssa()
+ want1 := uint64(6)
+ if x1 != want1 {
+ println("sub1_ssa()=", want1, ", got", x1)
+ failed = true
+ }
+ x2 := sub2_ssa()
+ want2 := uint8(251)
+ if x2 != want2 {
+ println("sub2_ssa()=", want2, ", got", x2)
+ failed = true
+ }
+}
+
+//go:noinline
+func orPhi_ssa(a bool, x int) int {
+ v := 0
+ if a {
+ v = -1
+ } else {
+ v = -1
+ }
+ return x | v
+}
+
+func testOrPhi() {
+ if want, got := -1, orPhi_ssa(true, 4); got != want {
+ println("orPhi_ssa(true, 4)=", got, " want ", want)
+ }
+ if want, got := -1, orPhi_ssa(false, 0); got != want {
+ println("orPhi_ssa(false, 0)=", got, " want ", want)
+ }
+}
+
+var failed = false
+
+func main() {
+
+ test64BitConstMult()
+ test64BitConstAdd()
+ testRegallocCVSpill()
+ testSubqToNegq()
+ testBitwiseLogic()
+ testOcom()
+ testLrot()
+ testShiftCX()
+ testSubConst()
+ testOverflowConstShift()
+ testArithConstShift()
+ testArithRshConst()
+ testLargeConst()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/array_ssa.go b/src/cmd/compile/internal/gc/testdata/array_ssa.go
new file mode 100644
index 0000000..0334339
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/array_ssa.go
@@ -0,0 +1,142 @@
+package main
+
+var failed = false
+
+//go:noinline
+func testSliceLenCap12_ssa(a [10]int, i, j int) (int, int) {
+ b := a[i:j]
+ return len(b), cap(b)
+}
+
+//go:noinline
+func testSliceLenCap1_ssa(a [10]int, i, j int) (int, int) {
+ b := a[i:]
+ return len(b), cap(b)
+}
+
+//go:noinline
+func testSliceLenCap2_ssa(a [10]int, i, j int) (int, int) {
+ b := a[:j]
+ return len(b), cap(b)
+}
+
+func testSliceLenCap() {
+ a := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+ tests := [...]struct {
+ fn func(a [10]int, i, j int) (int, int)
+ i, j int // slice range
+ l, c int // len, cap
+ }{
+ // -1 means the value is not used.
+ {testSliceLenCap12_ssa, 0, 0, 0, 10},
+ {testSliceLenCap12_ssa, 0, 1, 1, 10},
+ {testSliceLenCap12_ssa, 0, 10, 10, 10},
+ {testSliceLenCap12_ssa, 10, 10, 0, 0},
+ {testSliceLenCap12_ssa, 0, 5, 5, 10},
+ {testSliceLenCap12_ssa, 5, 5, 0, 5},
+ {testSliceLenCap12_ssa, 5, 10, 5, 5},
+ {testSliceLenCap1_ssa, 0, -1, 0, 10},
+ {testSliceLenCap1_ssa, 5, -1, 5, 5},
+ {testSliceLenCap1_ssa, 10, -1, 0, 0},
+ {testSliceLenCap2_ssa, -1, 0, 0, 10},
+ {testSliceLenCap2_ssa, -1, 5, 5, 10},
+ {testSliceLenCap2_ssa, -1, 10, 10, 10},
+ }
+
+ for i, t := range tests {
+ if l, c := t.fn(a, t.i, t.j); l != t.l && c != t.c {
+ println("#", i, " len(a[", t.i, ":", t.j, "]), cap(a[", t.i, ":", t.j, "]) =", l, c,
+ ", want", t.l, t.c)
+ failed = true
+ }
+ }
+}
+
+//go:noinline
+func testSliceGetElement_ssa(a [10]int, i, j, p int) int {
+ return a[i:j][p]
+}
+
+func testSliceGetElement() {
+ a := [10]int{0, 10, 20, 30, 40, 50, 60, 70, 80, 90}
+ tests := [...]struct {
+ i, j, p int
+ want int // a[i:j][p]
+ }{
+ {0, 10, 2, 20},
+ {0, 5, 4, 40},
+ {5, 10, 3, 80},
+ {1, 9, 7, 80},
+ }
+
+ for i, t := range tests {
+ if got := testSliceGetElement_ssa(a, t.i, t.j, t.p); got != t.want {
+ println("#", i, " a[", t.i, ":", t.j, "][", t.p, "] = ", got, " wanted ", t.want)
+ failed = true
+ }
+ }
+}
+
+//go:noinline
+func testSliceSetElement_ssa(a *[10]int, i, j, p, x int) {
+ (*a)[i:j][p] = x
+}
+
+func testSliceSetElement() {
+ a := [10]int{0, 10, 20, 30, 40, 50, 60, 70, 80, 90}
+ tests := [...]struct {
+ i, j, p int
+ want int // a[i:j][p]
+ }{
+ {0, 10, 2, 17},
+ {0, 5, 4, 11},
+ {5, 10, 3, 28},
+ {1, 9, 7, 99},
+ }
+
+ for i, t := range tests {
+ testSliceSetElement_ssa(&a, t.i, t.j, t.p, t.want)
+ if got := a[t.i+t.p]; got != t.want {
+ println("#", i, " a[", t.i, ":", t.j, "][", t.p, "] = ", got, " wanted ", t.want)
+ failed = true
+ }
+ }
+}
+
+func testSlicePanic1() {
+ defer func() {
+ if r := recover(); r != nil {
+ println("paniced as expected")
+ }
+ }()
+
+ a := [10]int{0, 10, 20, 30, 40, 50, 60, 70, 80, 90}
+ testSliceLenCap12_ssa(a, 3, 12)
+ println("expected to panic, but didn't")
+ failed = true
+}
+
+func testSlicePanic2() {
+ defer func() {
+ if r := recover(); r != nil {
+ println("paniced as expected")
+ }
+ }()
+
+ a := [10]int{0, 10, 20, 30, 40, 50, 60, 70, 80, 90}
+ testSliceGetElement_ssa(a, 3, 7, 4)
+ println("expected to panic, but didn't")
+ failed = true
+}
+
+func main() {
+ testSliceLenCap()
+ testSliceGetElement()
+ testSliceSetElement()
+ testSlicePanic1()
+ testSlicePanic2()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/assert_ssa.go b/src/cmd/compile/internal/gc/testdata/assert_ssa.go
new file mode 100644
index 0000000..d64d4fc
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/assert_ssa.go
@@ -0,0 +1,147 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests type assertion expressions and statements
+
+package main
+
+import (
+ "fmt"
+ "runtime"
+)
+
+type (
+ S struct{}
+ T struct{}
+
+ I interface {
+ F()
+ }
+)
+
+var (
+ s *S
+ t *T
+)
+
+func (s *S) F() {}
+func (t *T) F() {}
+
+func e2t_ssa(e interface{}) *T {
+ return e.(*T)
+}
+
+func i2t_ssa(i I) *T {
+ return i.(*T)
+}
+
+func testAssertE2TOk() {
+ if got := e2t_ssa(t); got != t {
+ fmt.Printf("e2t_ssa(t)=%v want %v", got, t)
+ failed = true
+ }
+}
+
+func testAssertE2TPanic() {
+ var got *T
+ defer func() {
+ if got != nil {
+ fmt.Printf("e2t_ssa(s)=%v want nil", got)
+ failed = true
+ }
+ e := recover()
+ err, ok := e.(*runtime.TypeAssertionError)
+ if !ok {
+ fmt.Printf("e2t_ssa(s) panic type %T", e)
+ failed = true
+ }
+ want := "interface conversion: interface {} is *main.S, not *main.T"
+ if err.Error() != want {
+ fmt.Printf("e2t_ssa(s) wrong error, want '%s', got '%s'\n", want, err.Error())
+ failed = true
+ }
+ }()
+ got = e2t_ssa(s)
+ fmt.Printf("e2t_ssa(s) should panic")
+ failed = true
+}
+
+func testAssertI2TOk() {
+ if got := i2t_ssa(t); got != t {
+ fmt.Printf("i2t_ssa(t)=%v want %v", got, t)
+ failed = true
+ }
+}
+
+func testAssertI2TPanic() {
+ var got *T
+ defer func() {
+ if got != nil {
+ fmt.Printf("i2t_ssa(s)=%v want nil", got)
+ failed = true
+ }
+ e := recover()
+ err, ok := e.(*runtime.TypeAssertionError)
+ if !ok {
+ fmt.Printf("i2t_ssa(s) panic type %T", e)
+ failed = true
+ }
+ want := "interface conversion: main.I is *main.S, not *main.T"
+ if err.Error() != want {
+ fmt.Printf("i2t_ssa(s) wrong error, want '%s', got '%s'\n", want, err.Error())
+ failed = true
+ }
+ }()
+ got = i2t_ssa(s)
+ fmt.Printf("i2t_ssa(s) should panic")
+ failed = true
+}
+
+func e2t2_ssa(e interface{}) (*T, bool) {
+ t, ok := e.(*T)
+ return t, ok
+}
+
+func i2t2_ssa(i I) (*T, bool) {
+ t, ok := i.(*T)
+ return t, ok
+}
+
+func testAssertE2T2() {
+ if got, ok := e2t2_ssa(t); !ok || got != t {
+ fmt.Printf("e2t2_ssa(t)=(%v, %v) want (%v, %v)", got, ok, t, true)
+ failed = true
+ }
+ if got, ok := e2t2_ssa(s); ok || got != nil {
+ fmt.Printf("e2t2_ssa(s)=(%v, %v) want (%v, %v)", got, ok, nil, false)
+ failed = true
+ }
+}
+
+func testAssertI2T2() {
+ if got, ok := i2t2_ssa(t); !ok || got != t {
+ fmt.Printf("i2t2_ssa(t)=(%v, %v) want (%v, %v)", got, ok, t, true)
+ failed = true
+ }
+ if got, ok := i2t2_ssa(s); ok || got != nil {
+ fmt.Printf("i2t2_ssa(s)=(%v, %v) want (%v, %v)", got, ok, nil, false)
+ failed = true
+ }
+}
+
+var failed = false
+
+func main() {
+ testAssertE2TOk()
+ testAssertE2TPanic()
+ testAssertI2TOk()
+ testAssertI2TPanic()
+ testAssertE2T2()
+ testAssertI2T2()
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/break_ssa.go b/src/cmd/compile/internal/gc/testdata/break_ssa.go
new file mode 100644
index 0000000..855ef70
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/break_ssa.go
@@ -0,0 +1,255 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests continue and break.
+
+package main
+
+func continuePlain_ssa() int {
+ var n int
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ continue
+ }
+ n = i
+ }
+ return n
+}
+
+func continueLabeled_ssa() int {
+ var n int
+Next:
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ continue Next
+ }
+ n = i
+ }
+ return n
+}
+
+func continuePlainInner_ssa() int {
+ var n int
+ for j := 0; j < 30; j += 10 {
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ continue
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+func continueLabeledInner_ssa() int {
+ var n int
+ for j := 0; j < 30; j += 10 {
+ Next:
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ continue Next
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+func continueLabeledOuter_ssa() int {
+ var n int
+Next:
+ for j := 0; j < 30; j += 10 {
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ continue Next
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+func breakPlain_ssa() int {
+ var n int
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break
+ }
+ n = i
+ }
+ return n
+}
+
+func breakLabeled_ssa() int {
+ var n int
+Next:
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break Next
+ }
+ n = i
+ }
+ return n
+}
+
+func breakPlainInner_ssa() int {
+ var n int
+ for j := 0; j < 30; j += 10 {
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+func breakLabeledInner_ssa() int {
+ var n int
+ for j := 0; j < 30; j += 10 {
+ Next:
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break Next
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+func breakLabeledOuter_ssa() int {
+ var n int
+Next:
+ for j := 0; j < 30; j += 10 {
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break Next
+ }
+ n = i
+ }
+ n += j
+ }
+ return n
+}
+
+var g, h int // globals to ensure optimizations don't collapse our switch statements
+
+func switchPlain_ssa() int {
+ var n int
+ switch g {
+ case 0:
+ n = 1
+ break
+ n = 2
+ }
+ return n
+}
+
+func switchLabeled_ssa() int {
+ var n int
+Done:
+ switch g {
+ case 0:
+ n = 1
+ break Done
+ n = 2
+ }
+ return n
+}
+
+func switchPlainInner_ssa() int {
+ var n int
+ switch g {
+ case 0:
+ n = 1
+ switch h {
+ case 0:
+ n += 10
+ break
+ }
+ n = 2
+ }
+ return n
+}
+
+func switchLabeledInner_ssa() int {
+ var n int
+ switch g {
+ case 0:
+ n = 1
+ Done:
+ switch h {
+ case 0:
+ n += 10
+ break Done
+ }
+ n = 2
+ }
+ return n
+}
+
+func switchLabeledOuter_ssa() int {
+ var n int
+Done:
+ switch g {
+ case 0:
+ n = 1
+ switch h {
+ case 0:
+ n += 10
+ break Done
+ }
+ n = 2
+ }
+ return n
+}
+
+func main() {
+ tests := [...]struct {
+ name string
+ fn func() int
+ want int
+ }{
+ {"continuePlain_ssa", continuePlain_ssa, 9},
+ {"continueLabeled_ssa", continueLabeled_ssa, 9},
+ {"continuePlainInner_ssa", continuePlainInner_ssa, 29},
+ {"continueLabeledInner_ssa", continueLabeledInner_ssa, 29},
+ {"continueLabeledOuter_ssa", continueLabeledOuter_ssa, 5},
+
+ {"breakPlain_ssa", breakPlain_ssa, 5},
+ {"breakLabeled_ssa", breakLabeled_ssa, 5},
+ {"breakPlainInner_ssa", breakPlainInner_ssa, 25},
+ {"breakLabeledInner_ssa", breakLabeledInner_ssa, 25},
+ {"breakLabeledOuter_ssa", breakLabeledOuter_ssa, 5},
+
+ {"switchPlain_ssa", switchPlain_ssa, 1},
+ {"switchLabeled_ssa", switchLabeled_ssa, 1},
+ {"switchPlainInner_ssa", switchPlainInner_ssa, 2},
+ {"switchLabeledInner_ssa", switchLabeledInner_ssa, 2},
+ {"switchLabeledOuter_ssa", switchLabeledOuter_ssa, 11},
+
+ // no select tests; they're identical to switch
+ }
+
+ var failed bool
+ for _, test := range tests {
+ if got := test.fn(); test.fn() != test.want {
+ print(test.name, "()=", got, ", want ", test.want, "\n")
+ failed = true
+ }
+ }
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/chan_ssa.go b/src/cmd/compile/internal/gc/testdata/chan_ssa.go
new file mode 100644
index 0000000..0766fcd
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/chan_ssa.go
@@ -0,0 +1,73 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// chan_ssa.go tests chan operations.
+package main
+
+import "fmt"
+
+var failed = false
+
+//go:noinline
+func lenChan_ssa(v chan int) int {
+ return len(v)
+}
+
+//go:noinline
+func capChan_ssa(v chan int) int {
+ return cap(v)
+}
+
+func testLenChan() {
+
+ v := make(chan int, 10)
+ v <- 1
+ v <- 1
+ v <- 1
+
+ if want, got := 3, lenChan_ssa(v); got != want {
+ fmt.Printf("expected len(chan) = %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func testLenNilChan() {
+
+ var v chan int
+ if want, got := 0, lenChan_ssa(v); got != want {
+ fmt.Printf("expected len(nil) = %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func testCapChan() {
+
+ v := make(chan int, 25)
+
+ if want, got := 25, capChan_ssa(v); got != want {
+ fmt.Printf("expected cap(chan) = %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func testCapNilChan() {
+
+ var v chan int
+ if want, got := 0, capChan_ssa(v); got != want {
+ fmt.Printf("expected cap(nil) = %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func main() {
+ testLenChan()
+ testLenNilChan()
+
+ testCapChan()
+ testCapNilChan()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/closure_ssa.go b/src/cmd/compile/internal/gc/testdata/closure_ssa.go
new file mode 100644
index 0000000..70181bc
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/closure_ssa.go
@@ -0,0 +1,38 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// map_ssa.go tests map operations.
+package main
+
+import "fmt"
+
+var failed = false
+
+//go:noinline
+func testCFunc_ssa() int {
+ a := 0
+ b := func() {
+ switch {
+ }
+ a++
+ }
+ b()
+ b()
+ return a
+}
+
+func testCFunc() {
+ if want, got := 2, testCFunc_ssa(); got != want {
+ fmt.Printf("expected %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func main() {
+ testCFunc()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/cmp_ssa.go b/src/cmd/compile/internal/gc/testdata/cmp_ssa.go
new file mode 100644
index 0000000..ba420f2
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/cmp_ssa.go
@@ -0,0 +1,48 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// cmp_ssa.go tests compare simplification operations.
+package main
+
+import "fmt"
+
+var failed = false
+
+//go:noinline
+func eq_ssa(a int64) bool {
+ return 4+a == 10
+}
+
+//go:noinline
+func neq_ssa(a int64) bool {
+ return 10 != a+4
+}
+
+func testCmp() {
+ if wanted, got := true, eq_ssa(6); wanted != got {
+ fmt.Printf("eq_ssa: expected %v, got %v\n", wanted, got)
+ failed = true
+ }
+ if wanted, got := false, eq_ssa(7); wanted != got {
+ fmt.Printf("eq_ssa: expected %v, got %v\n", wanted, got)
+ failed = true
+ }
+
+ if wanted, got := false, neq_ssa(6); wanted != got {
+ fmt.Printf("neq_ssa: expected %v, got %v\n", wanted, got)
+ failed = true
+ }
+ if wanted, got := true, neq_ssa(7); wanted != got {
+ fmt.Printf("neq_ssa: expected %v, got %v\n", wanted, got)
+ failed = true
+ }
+}
+
+func main() {
+ testCmp()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/compound_ssa.go b/src/cmd/compile/internal/gc/testdata/compound_ssa.go
new file mode 100644
index 0000000..b0e4962
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/compound_ssa.go
@@ -0,0 +1,145 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test compound objects
+
+package main
+
+import "fmt"
+
+func string_ssa(a, b string, x bool) string {
+ s := ""
+ if x {
+ s = a
+ } else {
+ s = b
+ }
+ return s
+}
+
+func testString() {
+ a := "foo"
+ b := "barz"
+ if want, got := a, string_ssa(a, b, true); got != want {
+ fmt.Printf("string_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+ if want, got := b, string_ssa(a, b, false); got != want {
+ fmt.Printf("string_ssa(%v, %v, false) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+}
+
+func complex64_ssa(a, b complex64, x bool) complex64 {
+ switch {
+ }
+ var c complex64
+ if x {
+ c = a
+ } else {
+ c = b
+ }
+ return c
+}
+
+func complex128_ssa(a, b complex128, x bool) complex128 {
+ switch {
+ }
+ var c complex128
+ if x {
+ c = a
+ } else {
+ c = b
+ }
+ return c
+}
+
+func testComplex64() {
+ var a complex64 = 1 + 2i
+ var b complex64 = 3 + 4i
+
+ if want, got := a, complex64_ssa(a, b, true); got != want {
+ fmt.Printf("complex64_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+ if want, got := b, complex64_ssa(a, b, false); got != want {
+ fmt.Printf("complex64_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+}
+
+func testComplex128() {
+ var a complex128 = 1 + 2i
+ var b complex128 = 3 + 4i
+
+ if want, got := a, complex128_ssa(a, b, true); got != want {
+ fmt.Printf("complex128_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+ if want, got := b, complex128_ssa(a, b, false); got != want {
+ fmt.Printf("complex128_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+}
+
+func slice_ssa(a, b []byte, x bool) []byte {
+ var s []byte
+ if x {
+ s = a
+ } else {
+ s = b
+ }
+ return s
+}
+
+func testSlice() {
+ a := []byte{3, 4, 5}
+ b := []byte{7, 8, 9}
+ if want, got := byte(3), slice_ssa(a, b, true)[0]; got != want {
+ fmt.Printf("slice_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+ if want, got := byte(7), slice_ssa(a, b, false)[0]; got != want {
+ fmt.Printf("slice_ssa(%v, %v, false) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+}
+
+func interface_ssa(a, b interface{}, x bool) interface{} {
+ var s interface{}
+ if x {
+ s = a
+ } else {
+ s = b
+ }
+ return s
+}
+
+func testInterface() {
+ a := interface{}(3)
+ b := interface{}(4)
+ if want, got := 3, interface_ssa(a, b, true).(int); got != want {
+ fmt.Printf("interface_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+ if want, got := 4, interface_ssa(a, b, false).(int); got != want {
+ fmt.Printf("interface_ssa(%v, %v, false) = %v, want %v\n", a, b, got, want)
+ failed = true
+ }
+}
+
+var failed = false
+
+func main() {
+ testString()
+ testSlice()
+ testInterface()
+ testComplex64()
+ testComplex128()
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/copy_ssa.go b/src/cmd/compile/internal/gc/testdata/copy_ssa.go
new file mode 100644
index 0000000..44f0223
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/copy_ssa.go
@@ -0,0 +1,726 @@
+// run
+// autogenerated from gen/copyGen.go - do not edit!
+package main
+
+import "fmt"
+
+type T1 struct {
+ pre [8]byte
+ mid [1]byte
+ post [8]byte
+}
+
+func t1copy_ssa(y, x *[1]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1() {
+ a := T1{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1]byte{0}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1]byte{100}
+ t1copy_ssa(&a.mid, &x)
+ want := T1{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1]byte{100}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T2 struct {
+ pre [8]byte
+ mid [2]byte
+ post [8]byte
+}
+
+func t2copy_ssa(y, x *[2]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy2() {
+ a := T2{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [2]byte{0, 1}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [2]byte{100, 101}
+ t2copy_ssa(&a.mid, &x)
+ want := T2{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [2]byte{100, 101}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t2copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T3 struct {
+ pre [8]byte
+ mid [3]byte
+ post [8]byte
+}
+
+func t3copy_ssa(y, x *[3]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy3() {
+ a := T3{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [3]byte{0, 1, 2}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [3]byte{100, 101, 102}
+ t3copy_ssa(&a.mid, &x)
+ want := T3{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [3]byte{100, 101, 102}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t3copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T4 struct {
+ pre [8]byte
+ mid [4]byte
+ post [8]byte
+}
+
+func t4copy_ssa(y, x *[4]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy4() {
+ a := T4{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [4]byte{0, 1, 2, 3}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [4]byte{100, 101, 102, 103}
+ t4copy_ssa(&a.mid, &x)
+ want := T4{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [4]byte{100, 101, 102, 103}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t4copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T5 struct {
+ pre [8]byte
+ mid [5]byte
+ post [8]byte
+}
+
+func t5copy_ssa(y, x *[5]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy5() {
+ a := T5{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [5]byte{0, 1, 2, 3, 4}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [5]byte{100, 101, 102, 103, 104}
+ t5copy_ssa(&a.mid, &x)
+ want := T5{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [5]byte{100, 101, 102, 103, 104}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t5copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T6 struct {
+ pre [8]byte
+ mid [6]byte
+ post [8]byte
+}
+
+func t6copy_ssa(y, x *[6]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy6() {
+ a := T6{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [6]byte{0, 1, 2, 3, 4, 5}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [6]byte{100, 101, 102, 103, 104, 105}
+ t6copy_ssa(&a.mid, &x)
+ want := T6{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [6]byte{100, 101, 102, 103, 104, 105}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t6copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T7 struct {
+ pre [8]byte
+ mid [7]byte
+ post [8]byte
+}
+
+func t7copy_ssa(y, x *[7]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy7() {
+ a := T7{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [7]byte{0, 1, 2, 3, 4, 5, 6}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [7]byte{100, 101, 102, 103, 104, 105, 106}
+ t7copy_ssa(&a.mid, &x)
+ want := T7{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [7]byte{100, 101, 102, 103, 104, 105, 106}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t7copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T8 struct {
+ pre [8]byte
+ mid [8]byte
+ post [8]byte
+}
+
+func t8copy_ssa(y, x *[8]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy8() {
+ a := T8{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [8]byte{0, 1, 2, 3, 4, 5, 6, 7}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [8]byte{100, 101, 102, 103, 104, 105, 106, 107}
+ t8copy_ssa(&a.mid, &x)
+ want := T8{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [8]byte{100, 101, 102, 103, 104, 105, 106, 107}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t8copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T9 struct {
+ pre [8]byte
+ mid [9]byte
+ post [8]byte
+}
+
+func t9copy_ssa(y, x *[9]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy9() {
+ a := T9{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [9]byte{0, 1, 2, 3, 4, 5, 6, 7, 8}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [9]byte{100, 101, 102, 103, 104, 105, 106, 107, 108}
+ t9copy_ssa(&a.mid, &x)
+ want := T9{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [9]byte{100, 101, 102, 103, 104, 105, 106, 107, 108}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t9copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T10 struct {
+ pre [8]byte
+ mid [10]byte
+ post [8]byte
+}
+
+func t10copy_ssa(y, x *[10]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy10() {
+ a := T10{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [10]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [10]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109}
+ t10copy_ssa(&a.mid, &x)
+ want := T10{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [10]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t10copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T15 struct {
+ pre [8]byte
+ mid [15]byte
+ post [8]byte
+}
+
+func t15copy_ssa(y, x *[15]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy15() {
+ a := T15{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [15]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [15]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114}
+ t15copy_ssa(&a.mid, &x)
+ want := T15{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [15]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t15copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T16 struct {
+ pre [8]byte
+ mid [16]byte
+ post [8]byte
+}
+
+func t16copy_ssa(y, x *[16]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy16() {
+ a := T16{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [16]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115}
+ t16copy_ssa(&a.mid, &x)
+ want := T16{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [16]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t16copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T17 struct {
+ pre [8]byte
+ mid [17]byte
+ post [8]byte
+}
+
+func t17copy_ssa(y, x *[17]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy17() {
+ a := T17{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [17]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [17]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116}
+ t17copy_ssa(&a.mid, &x)
+ want := T17{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [17]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t17copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T23 struct {
+ pre [8]byte
+ mid [23]byte
+ post [8]byte
+}
+
+func t23copy_ssa(y, x *[23]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy23() {
+ a := T23{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [23]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [23]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
+ t23copy_ssa(&a.mid, &x)
+ want := T23{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [23]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t23copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T24 struct {
+ pre [8]byte
+ mid [24]byte
+ post [8]byte
+}
+
+func t24copy_ssa(y, x *[24]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy24() {
+ a := T24{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [24]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [24]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123}
+ t24copy_ssa(&a.mid, &x)
+ want := T24{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [24]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t24copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T25 struct {
+ pre [8]byte
+ mid [25]byte
+ post [8]byte
+}
+
+func t25copy_ssa(y, x *[25]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy25() {
+ a := T25{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [25]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [25]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124}
+ t25copy_ssa(&a.mid, &x)
+ want := T25{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [25]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t25copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T31 struct {
+ pre [8]byte
+ mid [31]byte
+ post [8]byte
+}
+
+func t31copy_ssa(y, x *[31]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy31() {
+ a := T31{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [31]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [31]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130}
+ t31copy_ssa(&a.mid, &x)
+ want := T31{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [31]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t31copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T32 struct {
+ pre [8]byte
+ mid [32]byte
+ post [8]byte
+}
+
+func t32copy_ssa(y, x *[32]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy32() {
+ a := T32{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [32]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [32]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131}
+ t32copy_ssa(&a.mid, &x)
+ want := T32{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [32]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t32copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T33 struct {
+ pre [8]byte
+ mid [33]byte
+ post [8]byte
+}
+
+func t33copy_ssa(y, x *[33]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy33() {
+ a := T33{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [33]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [33]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132}
+ t33copy_ssa(&a.mid, &x)
+ want := T33{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [33]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t33copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T63 struct {
+ pre [8]byte
+ mid [63]byte
+ post [8]byte
+}
+
+func t63copy_ssa(y, x *[63]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy63() {
+ a := T63{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [63]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [63]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162}
+ t63copy_ssa(&a.mid, &x)
+ want := T63{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [63]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t63copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T64 struct {
+ pre [8]byte
+ mid [64]byte
+ post [8]byte
+}
+
+func t64copy_ssa(y, x *[64]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy64() {
+ a := T64{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [64]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [64]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163}
+ t64copy_ssa(&a.mid, &x)
+ want := T64{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [64]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t64copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T65 struct {
+ pre [8]byte
+ mid [65]byte
+ post [8]byte
+}
+
+func t65copy_ssa(y, x *[65]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy65() {
+ a := T65{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [65]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [65]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164}
+ t65copy_ssa(&a.mid, &x)
+ want := T65{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [65]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t65copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1023 struct {
+ pre [8]byte
+ mid [1023]byte
+ post [8]byte
+}
+
+func t1023copy_ssa(y, x *[1023]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1023() {
+ a := T1023{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1023]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1023]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
+ t1023copy_ssa(&a.mid, &x)
+ want := T1023{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1023]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1023copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1024 struct {
+ pre [8]byte
+ mid [1024]byte
+ post [8]byte
+}
+
+func t1024copy_ssa(y, x *[1024]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1024() {
+ a := T1024{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1024]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1024]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123}
+ t1024copy_ssa(&a.mid, &x)
+ want := T1024{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1024]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1024copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1025 struct {
+ pre [8]byte
+ mid [1025]byte
+ post [8]byte
+}
+
+func t1025copy_ssa(y, x *[1025]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1025() {
+ a := T1025{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1025]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1025]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124}
+ t1025copy_ssa(&a.mid, &x)
+ want := T1025{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1025]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1025copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1031 struct {
+ pre [8]byte
+ mid [1031]byte
+ post [8]byte
+}
+
+func t1031copy_ssa(y, x *[1031]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1031() {
+ a := T1031{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1031]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1031]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130}
+ t1031copy_ssa(&a.mid, &x)
+ want := T1031{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1031]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1031copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1032 struct {
+ pre [8]byte
+ mid [1032]byte
+ post [8]byte
+}
+
+func t1032copy_ssa(y, x *[1032]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1032() {
+ a := T1032{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1032]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1032]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131}
+ t1032copy_ssa(&a.mid, &x)
+ want := T1032{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1032]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1032copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1033 struct {
+ pre [8]byte
+ mid [1033]byte
+ post [8]byte
+}
+
+func t1033copy_ssa(y, x *[1033]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1033() {
+ a := T1033{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1033]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1033]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132}
+ t1033copy_ssa(&a.mid, &x)
+ want := T1033{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1033]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1033copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1039 struct {
+ pre [8]byte
+ mid [1039]byte
+ post [8]byte
+}
+
+func t1039copy_ssa(y, x *[1039]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1039() {
+ a := T1039{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1039]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1039]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138}
+ t1039copy_ssa(&a.mid, &x)
+ want := T1039{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1039]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1039copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1040 struct {
+ pre [8]byte
+ mid [1040]byte
+ post [8]byte
+}
+
+func t1040copy_ssa(y, x *[1040]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1040() {
+ a := T1040{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1040]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1040]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139}
+ t1040copy_ssa(&a.mid, &x)
+ want := T1040{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1040]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1040copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1041 struct {
+ pre [8]byte
+ mid [1041]byte
+ post [8]byte
+}
+
+func t1041copy_ssa(y, x *[1041]byte) {
+ switch {
+ }
+ *y = *x
+}
+func testCopy1041() {
+ a := T1041{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1041]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ x := [1041]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140}
+ t1041copy_ssa(&a.mid, &x)
+ want := T1041{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [1041]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
+ if a != want {
+ fmt.Printf("t1041copy got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+var failed bool
+
+func main() {
+ testCopy1()
+ testCopy2()
+ testCopy3()
+ testCopy4()
+ testCopy5()
+ testCopy6()
+ testCopy7()
+ testCopy8()
+ testCopy9()
+ testCopy10()
+ testCopy15()
+ testCopy16()
+ testCopy17()
+ testCopy23()
+ testCopy24()
+ testCopy25()
+ testCopy31()
+ testCopy32()
+ testCopy33()
+ testCopy63()
+ testCopy64()
+ testCopy65()
+ testCopy1023()
+ testCopy1024()
+ testCopy1025()
+ testCopy1031()
+ testCopy1032()
+ testCopy1033()
+ testCopy1039()
+ testCopy1040()
+ testCopy1041()
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go
new file mode 100644
index 0000000..09880ef
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go
@@ -0,0 +1,161 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test control flow
+
+package main
+
+// nor_ssa calculates NOR(a, b).
+// It is implemented in a way that generates
+// phi control values.
+func nor_ssa(a, b bool) bool {
+ var c bool
+ if a {
+ c = true
+ }
+ if b {
+ c = true
+ }
+ if c {
+ return false
+ }
+ return true
+}
+
+func testPhiControl() {
+ tests := [...][3]bool{ // a, b, want
+ {false, false, true},
+ {true, false, false},
+ {false, true, false},
+ {true, true, false},
+ }
+ for _, test := range tests {
+ a, b := test[0], test[1]
+ got := nor_ssa(a, b)
+ want := test[2]
+ if want != got {
+ print("nor(", a, ", ", b, ")=", want, " got ", got, "\n")
+ failed = true
+ }
+ }
+}
+
+func emptyRange_ssa(b []byte) bool {
+ for _, x := range b {
+ _ = x
+ }
+ return true
+}
+
+func testEmptyRange() {
+ if !emptyRange_ssa([]byte{}) {
+ println("emptyRange_ssa([]byte{})=false, want true")
+ failed = true
+ }
+}
+
+func switch_ssa(a int) int {
+ ret := 0
+ switch a {
+ case 5:
+ ret += 5
+ case 4:
+ ret += 4
+ case 3:
+ ret += 3
+ case 2:
+ ret += 2
+ case 1:
+ ret += 1
+ }
+ return ret
+
+}
+
+func fallthrough_ssa(a int) int {
+ ret := 0
+ switch a {
+ case 5:
+ ret++
+ fallthrough
+ case 4:
+ ret++
+ fallthrough
+ case 3:
+ ret++
+ fallthrough
+ case 2:
+ ret++
+ fallthrough
+ case 1:
+ ret++
+ }
+ return ret
+
+}
+
+func testFallthrough() {
+ for i := 0; i < 6; i++ {
+ if got := fallthrough_ssa(i); got != i {
+ println("fallthrough_ssa(i) =", got, "wanted", i)
+ failed = true
+ }
+ }
+}
+
+func testSwitch() {
+ for i := 0; i < 6; i++ {
+ if got := switch_ssa(i); got != i {
+ println("switch_ssa(i) =", got, "wanted", i)
+ failed = true
+ }
+ }
+}
+
+type junk struct {
+ step int
+}
+
+// flagOverwrite_ssa is intended to reproduce an issue seen where a XOR
+// was scheduled between a compare and branch, clearing flags.
+func flagOverwrite_ssa(s *junk, c int) int {
+ switch {
+ }
+ if '0' <= c && c <= '9' {
+ s.step = 0
+ return 1
+ }
+ if c == 'e' || c == 'E' {
+ s.step = 0
+ return 2
+ }
+ s.step = 0
+ return 3
+}
+
+func testFlagOverwrite() {
+ j := junk{}
+ if got := flagOverwrite_ssa(&j, ' '); got != 3 {
+ println("flagOverwrite_ssa =", got, "wanted 3")
+ failed = true
+ }
+}
+
+var failed = false
+
+func main() {
+ testPhiControl()
+ testEmptyRange()
+
+ testSwitch()
+ testFallthrough()
+
+ testFlagOverwrite()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go b/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go
new file mode 100644
index 0000000..7578dd5
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go
@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that a defer in a function with no return
+// statement will compile correctly.
+
+package foo
+
+func deferNoReturn_ssa() {
+ defer func() { println("returned") }()
+ for {
+ println("loop")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go
new file mode 100644
index 0000000..cfbdcda
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go
@@ -0,0 +1,1741 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests floating point arithmetic expressions
+
+package main
+
+import "fmt"
+
+// manysub_ssa is designed to tickle bugs that depend on register
+// pressure or unfriendly operand ordering in registers (and at
+// least once it succeeded in this).
+func manysub_ssa(a, b, c, d float64) (aa, ab, ac, ad, ba, bb, bc, bd, ca, cb, cc, cd, da, db, dc, dd float64) {
+ switch {
+ }
+ aa = a + 11.0 - a
+ ab = a - b
+ ac = a - c
+ ad = a - d
+ ba = b - a
+ bb = b + 22.0 - b
+ bc = b - c
+ bd = b - d
+ ca = c - a
+ cb = c - b
+ cc = c + 33.0 - c
+ cd = c - d
+ da = d - a
+ db = d - b
+ dc = d - c
+ dd = d + 44.0 - d
+ return
+}
+
+// fpspill_ssa attempts to trigger a bug where phis with floating point values
+// were stored in non-fp registers causing an error in doasm.
+func fpspill_ssa(a int) float64 {
+ switch {
+ }
+
+ ret := -1.0
+ switch a {
+ case 0:
+ ret = 1.0
+ case 1:
+ ret = 1.1
+ case 2:
+ ret = 1.2
+ case 3:
+ ret = 1.3
+ case 4:
+ ret = 1.4
+ case 5:
+ ret = 1.5
+ case 6:
+ ret = 1.6
+ case 7:
+ ret = 1.7
+ case 8:
+ ret = 1.8
+ case 9:
+ ret = 1.9
+ case 10:
+ ret = 1.10
+ case 11:
+ ret = 1.11
+ case 12:
+ ret = 1.12
+ case 13:
+ ret = 1.13
+ case 14:
+ ret = 1.14
+ case 15:
+ ret = 1.15
+ case 16:
+ ret = 1.16
+ }
+ return ret
+}
+
+func add64_ssa(a, b float64) float64 {
+ switch {
+ }
+ return a + b
+}
+
+func mul64_ssa(a, b float64) float64 {
+ switch {
+ }
+ return a * b
+}
+
+func sub64_ssa(a, b float64) float64 {
+ switch {
+ }
+ return a - b
+}
+
+func div64_ssa(a, b float64) float64 {
+ switch {
+ }
+ return a / b
+}
+
+func neg64_ssa(a, b float64) float64 {
+ switch {
+ }
+ return -a + -1*b
+}
+
+func add32_ssa(a, b float32) float32 {
+ switch {
+ }
+ return a + b
+}
+
+func mul32_ssa(a, b float32) float32 {
+ switch {
+ }
+ return a * b
+}
+
+func sub32_ssa(a, b float32) float32 {
+ switch {
+ }
+ return a - b
+}
+func div32_ssa(a, b float32) float32 {
+ switch {
+ }
+ return a / b
+}
+
+func neg32_ssa(a, b float32) float32 {
+ switch {
+ }
+ return -a + -1*b
+}
+
+func conv2Float64_ssa(a int8, b uint8, c int16, d uint16,
+ e int32, f uint32, g int64, h uint64, i float32) (aa, bb, cc, dd, ee, ff, gg, hh, ii float64) {
+ switch {
+ }
+ aa = float64(a)
+ bb = float64(b)
+ cc = float64(c)
+ hh = float64(h)
+ dd = float64(d)
+ ee = float64(e)
+ ff = float64(f)
+ gg = float64(g)
+ ii = float64(i)
+ return
+}
+
+func conv2Float32_ssa(a int8, b uint8, c int16, d uint16,
+ e int32, f uint32, g int64, h uint64, i float64) (aa, bb, cc, dd, ee, ff, gg, hh, ii float32) {
+ switch {
+ }
+ aa = float32(a)
+ bb = float32(b)
+ cc = float32(c)
+ dd = float32(d)
+ ee = float32(e)
+ ff = float32(f)
+ gg = float32(g)
+ hh = float32(h)
+ ii = float32(i)
+ return
+}
+
+func integer2floatConversions() int {
+ fails := 0
+ {
+ a, b, c, d, e, f, g, h, i := conv2Float64_ssa(0, 0, 0, 0, 0, 0, 0, 0, 0)
+ fails += expectAll64("zero64", 0, a, b, c, d, e, f, g, h, i)
+ }
+ {
+ a, b, c, d, e, f, g, h, i := conv2Float64_ssa(1, 1, 1, 1, 1, 1, 1, 1, 1)
+ fails += expectAll64("one64", 1, a, b, c, d, e, f, g, h, i)
+ }
+ {
+ a, b, c, d, e, f, g, h, i := conv2Float32_ssa(0, 0, 0, 0, 0, 0, 0, 0, 0)
+ fails += expectAll32("zero32", 0, a, b, c, d, e, f, g, h, i)
+ }
+ {
+ a, b, c, d, e, f, g, h, i := conv2Float32_ssa(1, 1, 1, 1, 1, 1, 1, 1, 1)
+ fails += expectAll32("one32", 1, a, b, c, d, e, f, g, h, i)
+ }
+ {
+ // Check maximum values
+ a, b, c, d, e, f, g, h, i := conv2Float64_ssa(127, 255, 32767, 65535, 0x7fffffff, 0xffffffff, 0x7fffFFFFffffFFFF, 0xffffFFFFffffFFFF, 3.402823E38)
+ fails += expect64("a", a, 127)
+ fails += expect64("b", b, 255)
+ fails += expect64("c", c, 32767)
+ fails += expect64("d", d, 65535)
+ fails += expect64("e", e, float64(int32(0x7fffffff)))
+ fails += expect64("f", f, float64(uint32(0xffffffff)))
+ fails += expect64("g", g, float64(int64(0x7fffffffffffffff)))
+ fails += expect64("h", h, float64(uint64(0xffffffffffffffff)))
+ fails += expect64("i", i, float64(float32(3.402823E38)))
+ }
+ {
+ // Check minimum values (and tweaks for unsigned)
+ a, b, c, d, e, f, g, h, i := conv2Float64_ssa(-128, 254, -32768, 65534, ^0x7fffffff, 0xfffffffe, ^0x7fffFFFFffffFFFF, 0xffffFFFFffffF401, 1.5E-45)
+ fails += expect64("a", a, -128)
+ fails += expect64("b", b, 254)
+ fails += expect64("c", c, -32768)
+ fails += expect64("d", d, 65534)
+ fails += expect64("e", e, float64(^int32(0x7fffffff)))
+ fails += expect64("f", f, float64(uint32(0xfffffffe)))
+ fails += expect64("g", g, float64(^int64(0x7fffffffffffffff)))
+ fails += expect64("h", h, float64(uint64(0xfffffffffffff401)))
+ fails += expect64("i", i, float64(float32(1.5E-45)))
+ }
+ {
+ // Check maximum values
+ a, b, c, d, e, f, g, h, i := conv2Float32_ssa(127, 255, 32767, 65535, 0x7fffffff, 0xffffffff, 0x7fffFFFFffffFFFF, 0xffffFFFFffffFFFF, 3.402823E38)
+ fails += expect32("a", a, 127)
+ fails += expect32("b", b, 255)
+ fails += expect32("c", c, 32767)
+ fails += expect32("d", d, 65535)
+ fails += expect32("e", e, float32(int32(0x7fffffff)))
+ fails += expect32("f", f, float32(uint32(0xffffffff)))
+ fails += expect32("g", g, float32(int64(0x7fffffffffffffff)))
+ fails += expect32("h", h, float32(uint64(0xffffffffffffffff)))
+ fails += expect32("i", i, float32(float64(3.402823E38)))
+ }
+ {
+ // Check minimum values (and tweaks for unsigned)
+ a, b, c, d, e, f, g, h, i := conv2Float32_ssa(-128, 254, -32768, 65534, ^0x7fffffff, 0xfffffffe, ^0x7fffFFFFffffFFFF, 0xffffFFFFffffF401, 1.5E-45)
+ fails += expect32("a", a, -128)
+ fails += expect32("b", b, 254)
+ fails += expect32("c", c, -32768)
+ fails += expect32("d", d, 65534)
+ fails += expect32("e", e, float32(^int32(0x7fffffff)))
+ fails += expect32("f", f, float32(uint32(0xfffffffe)))
+ fails += expect32("g", g, float32(^int64(0x7fffffffffffffff)))
+ fails += expect32("h", h, float32(uint64(0xfffffffffffff401)))
+ fails += expect32("i", i, float32(float64(1.5E-45)))
+ }
+ return fails
+}
+
+const (
+ aa = 0x1000000000000000
+ ab = 0x100000000000000
+ ac = 0x10000000000000
+ ad = 0x1000000000000
+ ba = 0x100000000000
+ bb = 0x10000000000
+ bc = 0x1000000000
+ bd = 0x100000000
+ ca = 0x10000000
+ cb = 0x1000000
+ cc = 0x100000
+ cd = 0x10000
+ da = 0x1000
+ db = 0x100
+ dc = 0x10
+ dd = 0x1
+)
+
+func compares64_ssa(a, b, c, d float64) (lt, le, eq, ne, ge, gt uint64) {
+
+ switch {
+ }
+
+ if a < a {
+ lt += aa
+ }
+ if a < b {
+ lt += ab
+ }
+ if a < c {
+ lt += ac
+ }
+ if a < d {
+ lt += ad
+ }
+
+ if b < a {
+ lt += ba
+ }
+ if b < b {
+ lt += bb
+ }
+ if b < c {
+ lt += bc
+ }
+ if b < d {
+ lt += bd
+ }
+
+ if c < a {
+ lt += ca
+ }
+ if c < b {
+ lt += cb
+ }
+ if c < c {
+ lt += cc
+ }
+ if c < d {
+ lt += cd
+ }
+
+ if d < a {
+ lt += da
+ }
+ if d < b {
+ lt += db
+ }
+ if d < c {
+ lt += dc
+ }
+ if d < d {
+ lt += dd
+ }
+
+ if a <= a {
+ le += aa
+ }
+ if a <= b {
+ le += ab
+ }
+ if a <= c {
+ le += ac
+ }
+ if a <= d {
+ le += ad
+ }
+
+ if b <= a {
+ le += ba
+ }
+ if b <= b {
+ le += bb
+ }
+ if b <= c {
+ le += bc
+ }
+ if b <= d {
+ le += bd
+ }
+
+ if c <= a {
+ le += ca
+ }
+ if c <= b {
+ le += cb
+ }
+ if c <= c {
+ le += cc
+ }
+ if c <= d {
+ le += cd
+ }
+
+ if d <= a {
+ le += da
+ }
+ if d <= b {
+ le += db
+ }
+ if d <= c {
+ le += dc
+ }
+ if d <= d {
+ le += dd
+ }
+
+ if a == a {
+ eq += aa
+ }
+ if a == b {
+ eq += ab
+ }
+ if a == c {
+ eq += ac
+ }
+ if a == d {
+ eq += ad
+ }
+
+ if b == a {
+ eq += ba
+ }
+ if b == b {
+ eq += bb
+ }
+ if b == c {
+ eq += bc
+ }
+ if b == d {
+ eq += bd
+ }
+
+ if c == a {
+ eq += ca
+ }
+ if c == b {
+ eq += cb
+ }
+ if c == c {
+ eq += cc
+ }
+ if c == d {
+ eq += cd
+ }
+
+ if d == a {
+ eq += da
+ }
+ if d == b {
+ eq += db
+ }
+ if d == c {
+ eq += dc
+ }
+ if d == d {
+ eq += dd
+ }
+
+ if a != a {
+ ne += aa
+ }
+ if a != b {
+ ne += ab
+ }
+ if a != c {
+ ne += ac
+ }
+ if a != d {
+ ne += ad
+ }
+
+ if b != a {
+ ne += ba
+ }
+ if b != b {
+ ne += bb
+ }
+ if b != c {
+ ne += bc
+ }
+ if b != d {
+ ne += bd
+ }
+
+ if c != a {
+ ne += ca
+ }
+ if c != b {
+ ne += cb
+ }
+ if c != c {
+ ne += cc
+ }
+ if c != d {
+ ne += cd
+ }
+
+ if d != a {
+ ne += da
+ }
+ if d != b {
+ ne += db
+ }
+ if d != c {
+ ne += dc
+ }
+ if d != d {
+ ne += dd
+ }
+
+ if a >= a {
+ ge += aa
+ }
+ if a >= b {
+ ge += ab
+ }
+ if a >= c {
+ ge += ac
+ }
+ if a >= d {
+ ge += ad
+ }
+
+ if b >= a {
+ ge += ba
+ }
+ if b >= b {
+ ge += bb
+ }
+ if b >= c {
+ ge += bc
+ }
+ if b >= d {
+ ge += bd
+ }
+
+ if c >= a {
+ ge += ca
+ }
+ if c >= b {
+ ge += cb
+ }
+ if c >= c {
+ ge += cc
+ }
+ if c >= d {
+ ge += cd
+ }
+
+ if d >= a {
+ ge += da
+ }
+ if d >= b {
+ ge += db
+ }
+ if d >= c {
+ ge += dc
+ }
+ if d >= d {
+ ge += dd
+ }
+
+ if a > a {
+ gt += aa
+ }
+ if a > b {
+ gt += ab
+ }
+ if a > c {
+ gt += ac
+ }
+ if a > d {
+ gt += ad
+ }
+
+ if b > a {
+ gt += ba
+ }
+ if b > b {
+ gt += bb
+ }
+ if b > c {
+ gt += bc
+ }
+ if b > d {
+ gt += bd
+ }
+
+ if c > a {
+ gt += ca
+ }
+ if c > b {
+ gt += cb
+ }
+ if c > c {
+ gt += cc
+ }
+ if c > d {
+ gt += cd
+ }
+
+ if d > a {
+ gt += da
+ }
+ if d > b {
+ gt += db
+ }
+ if d > c {
+ gt += dc
+ }
+ if d > d {
+ gt += dd
+ }
+
+ return
+}
+
+func compares32_ssa(a, b, c, d float32) (lt, le, eq, ne, ge, gt uint64) {
+
+ switch {
+ }
+
+ if a < a {
+ lt += aa
+ }
+ if a < b {
+ lt += ab
+ }
+ if a < c {
+ lt += ac
+ }
+ if a < d {
+ lt += ad
+ }
+
+ if b < a {
+ lt += ba
+ }
+ if b < b {
+ lt += bb
+ }
+ if b < c {
+ lt += bc
+ }
+ if b < d {
+ lt += bd
+ }
+
+ if c < a {
+ lt += ca
+ }
+ if c < b {
+ lt += cb
+ }
+ if c < c {
+ lt += cc
+ }
+ if c < d {
+ lt += cd
+ }
+
+ if d < a {
+ lt += da
+ }
+ if d < b {
+ lt += db
+ }
+ if d < c {
+ lt += dc
+ }
+ if d < d {
+ lt += dd
+ }
+
+ if a <= a {
+ le += aa
+ }
+ if a <= b {
+ le += ab
+ }
+ if a <= c {
+ le += ac
+ }
+ if a <= d {
+ le += ad
+ }
+
+ if b <= a {
+ le += ba
+ }
+ if b <= b {
+ le += bb
+ }
+ if b <= c {
+ le += bc
+ }
+ if b <= d {
+ le += bd
+ }
+
+ if c <= a {
+ le += ca
+ }
+ if c <= b {
+ le += cb
+ }
+ if c <= c {
+ le += cc
+ }
+ if c <= d {
+ le += cd
+ }
+
+ if d <= a {
+ le += da
+ }
+ if d <= b {
+ le += db
+ }
+ if d <= c {
+ le += dc
+ }
+ if d <= d {
+ le += dd
+ }
+
+ if a == a {
+ eq += aa
+ }
+ if a == b {
+ eq += ab
+ }
+ if a == c {
+ eq += ac
+ }
+ if a == d {
+ eq += ad
+ }
+
+ if b == a {
+ eq += ba
+ }
+ if b == b {
+ eq += bb
+ }
+ if b == c {
+ eq += bc
+ }
+ if b == d {
+ eq += bd
+ }
+
+ if c == a {
+ eq += ca
+ }
+ if c == b {
+ eq += cb
+ }
+ if c == c {
+ eq += cc
+ }
+ if c == d {
+ eq += cd
+ }
+
+ if d == a {
+ eq += da
+ }
+ if d == b {
+ eq += db
+ }
+ if d == c {
+ eq += dc
+ }
+ if d == d {
+ eq += dd
+ }
+
+ if a != a {
+ ne += aa
+ }
+ if a != b {
+ ne += ab
+ }
+ if a != c {
+ ne += ac
+ }
+ if a != d {
+ ne += ad
+ }
+
+ if b != a {
+ ne += ba
+ }
+ if b != b {
+ ne += bb
+ }
+ if b != c {
+ ne += bc
+ }
+ if b != d {
+ ne += bd
+ }
+
+ if c != a {
+ ne += ca
+ }
+ if c != b {
+ ne += cb
+ }
+ if c != c {
+ ne += cc
+ }
+ if c != d {
+ ne += cd
+ }
+
+ if d != a {
+ ne += da
+ }
+ if d != b {
+ ne += db
+ }
+ if d != c {
+ ne += dc
+ }
+ if d != d {
+ ne += dd
+ }
+
+ if a >= a {
+ ge += aa
+ }
+ if a >= b {
+ ge += ab
+ }
+ if a >= c {
+ ge += ac
+ }
+ if a >= d {
+ ge += ad
+ }
+
+ if b >= a {
+ ge += ba
+ }
+ if b >= b {
+ ge += bb
+ }
+ if b >= c {
+ ge += bc
+ }
+ if b >= d {
+ ge += bd
+ }
+
+ if c >= a {
+ ge += ca
+ }
+ if c >= b {
+ ge += cb
+ }
+ if c >= c {
+ ge += cc
+ }
+ if c >= d {
+ ge += cd
+ }
+
+ if d >= a {
+ ge += da
+ }
+ if d >= b {
+ ge += db
+ }
+ if d >= c {
+ ge += dc
+ }
+ if d >= d {
+ ge += dd
+ }
+
+ if a > a {
+ gt += aa
+ }
+ if a > b {
+ gt += ab
+ }
+ if a > c {
+ gt += ac
+ }
+ if a > d {
+ gt += ad
+ }
+
+ if b > a {
+ gt += ba
+ }
+ if b > b {
+ gt += bb
+ }
+ if b > c {
+ gt += bc
+ }
+ if b > d {
+ gt += bd
+ }
+
+ if c > a {
+ gt += ca
+ }
+ if c > b {
+ gt += cb
+ }
+ if c > c {
+ gt += cc
+ }
+ if c > d {
+ gt += cd
+ }
+
+ if d > a {
+ gt += da
+ }
+ if d > b {
+ gt += db
+ }
+ if d > c {
+ gt += dc
+ }
+ if d > d {
+ gt += dd
+ }
+
+ return
+}
+
+func le64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x <= y
+}
+func ge64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x >= y
+}
+func lt64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x < y
+}
+func gt64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x > y
+}
+func eq64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x == y
+}
+func ne64_ssa(x, y float64) bool {
+ switch {
+ }
+ return x != y
+}
+
+func eqbr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x == y {
+ return 17
+ }
+ return 42
+}
+func nebr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x != y {
+ return 17
+ }
+ return 42
+}
+func gebr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x >= y {
+ return 17
+ }
+ return 42
+}
+func lebr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x <= y {
+ return 17
+ }
+ return 42
+}
+func ltbr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x < y {
+ return 17
+ }
+ return 42
+}
+func gtbr64_ssa(x, y float64) float64 {
+ switch {
+ }
+ if x > y {
+ return 17
+ }
+ return 42
+}
+
+func le32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x <= y
+}
+func ge32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x >= y
+}
+func lt32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x < y
+}
+func gt32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x > y
+}
+func eq32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x == y
+}
+func ne32_ssa(x, y float32) bool {
+ switch {
+ }
+ return x != y
+}
+
+func eqbr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x == y {
+ return 17
+ }
+ return 42
+}
+func nebr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x != y {
+ return 17
+ }
+ return 42
+}
+func gebr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x >= y {
+ return 17
+ }
+ return 42
+}
+func lebr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x <= y {
+ return 17
+ }
+ return 42
+}
+func ltbr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x < y {
+ return 17
+ }
+ return 42
+}
+func gtbr32_ssa(x, y float32) float32 {
+ switch {
+ }
+ if x > y {
+ return 17
+ }
+ return 42
+}
+
+func F32toU8_ssa(x float32) uint8 {
+ switch {
+ }
+ return uint8(x)
+}
+
+func F32toI8_ssa(x float32) int8 {
+ switch {
+ }
+ return int8(x)
+}
+
+func F32toU16_ssa(x float32) uint16 {
+ switch {
+ }
+ return uint16(x)
+}
+
+func F32toI16_ssa(x float32) int16 {
+ switch {
+ }
+ return int16(x)
+}
+
+func F32toU32_ssa(x float32) uint32 {
+ switch {
+ }
+ return uint32(x)
+}
+
+func F32toI32_ssa(x float32) int32 {
+ switch {
+ }
+ return int32(x)
+}
+
+func F32toU64_ssa(x float32) uint64 {
+ switch {
+ }
+ return uint64(x)
+}
+
+func F32toI64_ssa(x float32) int64 {
+ switch {
+ }
+ return int64(x)
+}
+
+func F64toU8_ssa(x float64) uint8 {
+ switch {
+ }
+ return uint8(x)
+}
+
+func F64toI8_ssa(x float64) int8 {
+ switch {
+ }
+ return int8(x)
+}
+
+func F64toU16_ssa(x float64) uint16 {
+ switch {
+ }
+ return uint16(x)
+}
+
+func F64toI16_ssa(x float64) int16 {
+ switch {
+ }
+ return int16(x)
+}
+
+func F64toU32_ssa(x float64) uint32 {
+ switch {
+ }
+ return uint32(x)
+}
+
+func F64toI32_ssa(x float64) int32 {
+ switch {
+ }
+ return int32(x)
+}
+
+func F64toU64_ssa(x float64) uint64 {
+ switch {
+ }
+ return uint64(x)
+}
+
+func F64toI64_ssa(x float64) int64 {
+ switch {
+ }
+ return int64(x)
+}
+
+func floatsToInts(x float64, expected int64) int {
+ y := float32(x)
+ fails := 0
+ fails += expectInt64("F64toI8", int64(F64toI8_ssa(x)), expected)
+ fails += expectInt64("F64toI16", int64(F64toI16_ssa(x)), expected)
+ fails += expectInt64("F64toI32", int64(F64toI32_ssa(x)), expected)
+ fails += expectInt64("F64toI64", int64(F64toI64_ssa(x)), expected)
+ fails += expectInt64("F32toI8", int64(F32toI8_ssa(y)), expected)
+ fails += expectInt64("F32toI16", int64(F32toI16_ssa(y)), expected)
+ fails += expectInt64("F32toI32", int64(F32toI32_ssa(y)), expected)
+ fails += expectInt64("F32toI64", int64(F32toI64_ssa(y)), expected)
+ return fails
+}
+
+func floatsToUints(x float64, expected uint64) int {
+ y := float32(x)
+ fails := 0
+ fails += expectUint64("F64toU8", uint64(F64toU8_ssa(x)), expected)
+ fails += expectUint64("F64toU16", uint64(F64toU16_ssa(x)), expected)
+ fails += expectUint64("F64toU32", uint64(F64toU32_ssa(x)), expected)
+ fails += expectUint64("F64toU64", uint64(F64toU64_ssa(x)), expected)
+ fails += expectUint64("F32toU8", uint64(F32toU8_ssa(y)), expected)
+ fails += expectUint64("F32toU16", uint64(F32toU16_ssa(y)), expected)
+ fails += expectUint64("F32toU32", uint64(F32toU32_ssa(y)), expected)
+ fails += expectUint64("F32toU64", uint64(F32toU64_ssa(y)), expected)
+ return fails
+}
+
+func floatingToIntegerConversionsTest() int {
+ fails := 0
+ fails += floatsToInts(0.0, 0)
+ fails += floatsToInts(0.5, 0)
+ fails += floatsToInts(0.9, 0)
+ fails += floatsToInts(1.0, 1)
+ fails += floatsToInts(1.5, 1)
+ fails += floatsToInts(127.0, 127)
+ fails += floatsToInts(-1.0, -1)
+ fails += floatsToInts(-128.0, -128)
+
+ fails += floatsToUints(0.0, 0)
+ fails += floatsToUints(1.0, 1)
+ fails += floatsToUints(255.0, 255)
+
+ for j := uint(0); j < 24; j++ {
+ // Avoid hard cases in the construction
+ // of the test inputs.
+ v := int64(1<<62) | int64(1<<(62-j))
+ w := uint64(v)
+ f := float32(v)
+ d := float64(v)
+ fails += expectUint64("2**62...", F32toU64_ssa(f), w)
+ fails += expectUint64("2**62...", F64toU64_ssa(d), w)
+ fails += expectInt64("2**62...", F32toI64_ssa(f), v)
+ fails += expectInt64("2**62...", F64toI64_ssa(d), v)
+ fails += expectInt64("2**62...", F32toI64_ssa(-f), -v)
+ fails += expectInt64("2**62...", F64toI64_ssa(-d), -v)
+ w += w
+ f += f
+ d += d
+ fails += expectUint64("2**63...", F32toU64_ssa(f), w)
+ fails += expectUint64("2**63...", F64toU64_ssa(d), w)
+ }
+
+ for j := uint(0); j < 16; j++ {
+ // Avoid hard cases in the construction
+ // of the test inputs.
+ v := int32(1<<30) | int32(1<<(30-j))
+ w := uint32(v)
+ f := float32(v)
+ d := float64(v)
+ fails += expectUint32("2**30...", F32toU32_ssa(f), w)
+ fails += expectUint32("2**30...", F64toU32_ssa(d), w)
+ fails += expectInt32("2**30...", F32toI32_ssa(f), v)
+ fails += expectInt32("2**30...", F64toI32_ssa(d), v)
+ fails += expectInt32("2**30...", F32toI32_ssa(-f), -v)
+ fails += expectInt32("2**30...", F64toI32_ssa(-d), -v)
+ w += w
+ f += f
+ d += d
+ fails += expectUint32("2**31...", F32toU32_ssa(f), w)
+ fails += expectUint32("2**31...", F64toU32_ssa(d), w)
+ }
+
+ for j := uint(0); j < 15; j++ {
+ // Avoid hard cases in the construction
+ // of the test inputs.
+ v := int16(1<<14) | int16(1<<(14-j))
+ w := uint16(v)
+ f := float32(v)
+ d := float64(v)
+ fails += expectUint16("2**14...", F32toU16_ssa(f), w)
+ fails += expectUint16("2**14...", F64toU16_ssa(d), w)
+ fails += expectInt16("2**14...", F32toI16_ssa(f), v)
+ fails += expectInt16("2**14...", F64toI16_ssa(d), v)
+ fails += expectInt16("2**14...", F32toI16_ssa(-f), -v)
+ fails += expectInt16("2**14...", F64toI16_ssa(-d), -v)
+ w += w
+ f += f
+ d += d
+ fails += expectUint16("2**15...", F32toU16_ssa(f), w)
+ fails += expectUint16("2**15...", F64toU16_ssa(d), w)
+ }
+
+ fails += expectInt32("-2147483648", F32toI32_ssa(-2147483648), -2147483648)
+
+ fails += expectInt32("-2147483648", F64toI32_ssa(-2147483648), -2147483648)
+ fails += expectInt32("-2147483647", F64toI32_ssa(-2147483647), -2147483647)
+ fails += expectUint32("4294967295", F64toU32_ssa(4294967295), 4294967295)
+
+ fails += expectInt16("-32768", F64toI16_ssa(-32768), -32768)
+ fails += expectInt16("-32768", F32toI16_ssa(-32768), -32768)
+
+ // NB more of a pain to do these for 32-bit because of lost bits in Float32 mantissa
+ fails += expectInt16("32767", F64toI16_ssa(32767), 32767)
+ fails += expectInt16("32767", F32toI16_ssa(32767), 32767)
+ fails += expectUint16("32767", F64toU16_ssa(32767), 32767)
+ fails += expectUint16("32767", F32toU16_ssa(32767), 32767)
+ fails += expectUint16("65535", F64toU16_ssa(65535), 65535)
+ fails += expectUint16("65535", F32toU16_ssa(65535), 65535)
+
+ return fails
+}
+
+func fail64(s string, f func(a, b float64) float64, a, b, e float64) int {
+ d := f(a, b)
+ if d != e {
+ fmt.Printf("For (float64) %v %v %v, expected %v, got %v\n", a, s, b, e, d)
+ return 1
+ }
+ return 0
+}
+
+func fail64bool(s string, f func(a, b float64) bool, a, b float64, e bool) int {
+ d := f(a, b)
+ if d != e {
+ fmt.Printf("For (float64) %v %v %v, expected %v, got %v\n", a, s, b, e, d)
+ return 1
+ }
+ return 0
+}
+
+func fail32(s string, f func(a, b float32) float32, a, b, e float32) int {
+ d := f(a, b)
+ if d != e {
+ fmt.Printf("For (float32) %v %v %v, expected %v, got %v\n", a, s, b, e, d)
+ return 1
+ }
+ return 0
+}
+
+func fail32bool(s string, f func(a, b float32) bool, a, b float32, e bool) int {
+ d := f(a, b)
+ if d != e {
+ fmt.Printf("For (float32) %v %v %v, expected %v, got %v\n", a, s, b, e, d)
+ return 1
+ }
+ return 0
+}
+
+func expect64(s string, x, expected float64) int {
+ if x != expected {
+ println("F64 Expected", expected, "for", s, ", got", x)
+ return 1
+ }
+ return 0
+}
+
+func expect32(s string, x, expected float32) int {
+ if x != expected {
+ println("F32 Expected", expected, "for", s, ", got", x)
+ return 1
+ }
+ return 0
+}
+
+func expectUint64(s string, x, expected uint64) int {
+ if x != expected {
+ fmt.Printf("U64 Expected 0x%016x for %s, got 0x%016x\n", expected, s, x)
+ return 1
+ }
+ return 0
+}
+
+func expectInt64(s string, x, expected int64) int {
+ if x != expected {
+ fmt.Printf("%s: Expected 0x%016x, got 0x%016x\n", s, expected, x)
+ return 1
+ }
+ return 0
+}
+
+func expectUint32(s string, x, expected uint32) int {
+ if x != expected {
+ fmt.Printf("U32 %s: Expected 0x%08x, got 0x%08x\n", s, expected, x)
+ return 1
+ }
+ return 0
+}
+
+func expectInt32(s string, x, expected int32) int {
+ if x != expected {
+ fmt.Printf("I32 %s: Expected 0x%08x, got 0x%08x\n", s, expected, x)
+ return 1
+ }
+ return 0
+}
+
+func expectUint16(s string, x, expected uint16) int {
+ if x != expected {
+ fmt.Printf("U16 %s: Expected 0x%04x, got 0x%04x\n", s, expected, x)
+ return 1
+ }
+ return 0
+}
+
+func expectInt16(s string, x, expected int16) int {
+ if x != expected {
+ fmt.Printf("I16 %s: Expected 0x%04x, got 0x%04x\n", s, expected, x)
+ return 1
+ }
+ return 0
+}
+
+func expectAll64(s string, expected, a, b, c, d, e, f, g, h, i float64) int {
+ fails := 0
+ fails += expect64(s+":a", a, expected)
+ fails += expect64(s+":b", b, expected)
+ fails += expect64(s+":c", c, expected)
+ fails += expect64(s+":d", d, expected)
+ fails += expect64(s+":e", e, expected)
+ fails += expect64(s+":f", f, expected)
+ fails += expect64(s+":g", g, expected)
+ return fails
+}
+
+func expectAll32(s string, expected, a, b, c, d, e, f, g, h, i float32) int {
+ fails := 0
+ fails += expect32(s+":a", a, expected)
+ fails += expect32(s+":b", b, expected)
+ fails += expect32(s+":c", c, expected)
+ fails += expect32(s+":d", d, expected)
+ fails += expect32(s+":e", e, expected)
+ fails += expect32(s+":f", f, expected)
+ fails += expect32(s+":g", g, expected)
+ return fails
+}
+
+var ev64 [2]float64 = [2]float64{42.0, 17.0}
+var ev32 [2]float32 = [2]float32{42.0, 17.0}
+
+func cmpOpTest(s string,
+ f func(a, b float64) bool,
+ g func(a, b float64) float64,
+ ff func(a, b float32) bool,
+ gg func(a, b float32) float32,
+ zero, one, inf, nan float64, result uint) int {
+ fails := 0
+ fails += fail64bool(s, f, zero, zero, result>>16&1 == 1)
+ fails += fail64bool(s, f, zero, one, result>>12&1 == 1)
+ fails += fail64bool(s, f, zero, inf, result>>8&1 == 1)
+ fails += fail64bool(s, f, zero, nan, result>>4&1 == 1)
+ fails += fail64bool(s, f, nan, nan, result&1 == 1)
+
+ fails += fail64(s, g, zero, zero, ev64[result>>16&1])
+ fails += fail64(s, g, zero, one, ev64[result>>12&1])
+ fails += fail64(s, g, zero, inf, ev64[result>>8&1])
+ fails += fail64(s, g, zero, nan, ev64[result>>4&1])
+ fails += fail64(s, g, nan, nan, ev64[result>>0&1])
+
+ {
+ zero := float32(zero)
+ one := float32(one)
+ inf := float32(inf)
+ nan := float32(nan)
+ fails += fail32bool(s, ff, zero, zero, (result>>16)&1 == 1)
+ fails += fail32bool(s, ff, zero, one, (result>>12)&1 == 1)
+ fails += fail32bool(s, ff, zero, inf, (result>>8)&1 == 1)
+ fails += fail32bool(s, ff, zero, nan, (result>>4)&1 == 1)
+ fails += fail32bool(s, ff, nan, nan, result&1 == 1)
+
+ fails += fail32(s, gg, zero, zero, ev32[(result>>16)&1])
+ fails += fail32(s, gg, zero, one, ev32[(result>>12)&1])
+ fails += fail32(s, gg, zero, inf, ev32[(result>>8)&1])
+ fails += fail32(s, gg, zero, nan, ev32[(result>>4)&1])
+ fails += fail32(s, gg, nan, nan, ev32[(result>>0)&1])
+ }
+
+ return fails
+}
+
+func expectCx128(s string, x, expected complex128) int {
+ if x != expected {
+ println("Cx 128 Expected", expected, "for", s, ", got", x)
+ return 1
+ }
+ return 0
+}
+
+func expectCx64(s string, x, expected complex64) int {
+ if x != expected {
+ println("Cx 64 Expected", expected, "for", s, ", got", x)
+ return 1
+ }
+ return 0
+}
+
+//go:noinline
+func cx128sum_ssa(a, b complex128) complex128 {
+ return a + b
+}
+
+//go:noinline
+func cx128diff_ssa(a, b complex128) complex128 {
+ return a - b
+}
+
+//go:noinline
+func cx128prod_ssa(a, b complex128) complex128 {
+ return a * b
+}
+
+//go:noinline
+func cx128quot_ssa(a, b complex128) complex128 {
+ return a / b
+}
+
+//go:noinline
+func cx128neg_ssa(a complex128) complex128 {
+ return -a
+}
+
+//go:noinline
+func cx128real_ssa(a complex128) float64 {
+ return real(a)
+}
+
+//go:noinline
+func cx128imag_ssa(a complex128) float64 {
+ return imag(a)
+}
+
+//go:noinline
+func cx128cnst_ssa(a complex128) complex128 {
+ b := 2 + 3i
+ return a * b
+}
+
+//go:noinline
+func cx64sum_ssa(a, b complex64) complex64 {
+ return a + b
+}
+
+//go:noinline
+func cx64diff_ssa(a, b complex64) complex64 {
+ return a - b
+}
+
+//go:noinline
+func cx64prod_ssa(a, b complex64) complex64 {
+ return a * b
+}
+
+//go:noinline
+func cx64quot_ssa(a, b complex64) complex64 {
+ return a / b
+}
+
+//go:noinline
+func cx64neg_ssa(a complex64) complex64 {
+ return -a
+}
+
+//go:noinline
+func cx64real_ssa(a complex64) float32 {
+ return real(a)
+}
+
+//go:noinline
+func cx64imag_ssa(a complex64) float32 {
+ return imag(a)
+}
+
+//go:noinline
+func cx128eq_ssa(a, b complex128) bool {
+ return a == b
+}
+
+//go:noinline
+func cx128ne_ssa(a, b complex128) bool {
+ return a != b
+}
+
+//go:noinline
+func cx64eq_ssa(a, b complex64) bool {
+ return a == b
+}
+
+//go:noinline
+func cx64ne_ssa(a, b complex64) bool {
+ return a != b
+}
+
+func expectTrue(s string, b bool) int {
+ if !b {
+ println("expected true for", s, ", got false")
+ return 1
+ }
+ return 0
+}
+func expectFalse(s string, b bool) int {
+ if b {
+ println("expected false for", s, ", got true")
+ return 1
+ }
+ return 0
+}
+
+func complexTest128() int {
+ fails := 0
+ var a complex128 = 1 + 2i
+ var b complex128 = 3 + 6i
+ sum := cx128sum_ssa(b, a)
+ diff := cx128diff_ssa(b, a)
+ prod := cx128prod_ssa(b, a)
+ quot := cx128quot_ssa(b, a)
+ neg := cx128neg_ssa(a)
+ r := cx128real_ssa(a)
+ i := cx128imag_ssa(a)
+ cnst := cx128cnst_ssa(a)
+ c1 := cx128eq_ssa(a, a)
+ c2 := cx128eq_ssa(a, b)
+ c3 := cx128ne_ssa(a, a)
+ c4 := cx128ne_ssa(a, b)
+
+ fails += expectCx128("sum", sum, 4+8i)
+ fails += expectCx128("diff", diff, 2+4i)
+ fails += expectCx128("prod", prod, -9+12i)
+ fails += expectCx128("quot", quot, 3+0i)
+ fails += expectCx128("neg", neg, -1-2i)
+ fails += expect64("real", r, 1)
+ fails += expect64("imag", i, 2)
+ fails += expectCx128("cnst", cnst, -4+7i)
+ fails += expectTrue(fmt.Sprintf("%v==%v", a, a), c1)
+ fails += expectFalse(fmt.Sprintf("%v==%v", a, b), c2)
+ fails += expectFalse(fmt.Sprintf("%v!=%v", a, a), c3)
+ fails += expectTrue(fmt.Sprintf("%v!=%v", a, b), c4)
+
+ return fails
+}
+
+func complexTest64() int {
+ fails := 0
+ var a complex64 = 1 + 2i
+ var b complex64 = 3 + 6i
+ sum := cx64sum_ssa(b, a)
+ diff := cx64diff_ssa(b, a)
+ prod := cx64prod_ssa(b, a)
+ quot := cx64quot_ssa(b, a)
+ neg := cx64neg_ssa(a)
+ r := cx64real_ssa(a)
+ i := cx64imag_ssa(a)
+ c1 := cx64eq_ssa(a, a)
+ c2 := cx64eq_ssa(a, b)
+ c3 := cx64ne_ssa(a, a)
+ c4 := cx64ne_ssa(a, b)
+
+ fails += expectCx64("sum", sum, 4+8i)
+ fails += expectCx64("diff", diff, 2+4i)
+ fails += expectCx64("prod", prod, -9+12i)
+ fails += expectCx64("quot", quot, 3+0i)
+ fails += expectCx64("neg", neg, -1-2i)
+ fails += expect32("real", r, 1)
+ fails += expect32("imag", i, 2)
+ fails += expectTrue(fmt.Sprintf("%v==%v", a, a), c1)
+ fails += expectFalse(fmt.Sprintf("%v==%v", a, b), c2)
+ fails += expectFalse(fmt.Sprintf("%v!=%v", a, a), c3)
+ fails += expectTrue(fmt.Sprintf("%v!=%v", a, b), c4)
+
+ return fails
+}
+
+func main() {
+
+ a := 3.0
+ b := 4.0
+
+ c := float32(3.0)
+ d := float32(4.0)
+
+ tiny := float32(1.5E-45) // smallest f32 denorm = 2**(-149)
+ dtiny := float64(tiny) // well within range of f64
+
+ fails := 0
+ fails += fail64("+", add64_ssa, a, b, 7.0)
+ fails += fail64("*", mul64_ssa, a, b, 12.0)
+ fails += fail64("-", sub64_ssa, a, b, -1.0)
+ fails += fail64("/", div64_ssa, a, b, 0.75)
+ fails += fail64("neg", neg64_ssa, a, b, -7)
+
+ fails += fail32("+", add32_ssa, c, d, 7.0)
+ fails += fail32("*", mul32_ssa, c, d, 12.0)
+ fails += fail32("-", sub32_ssa, c, d, -1.0)
+ fails += fail32("/", div32_ssa, c, d, 0.75)
+ fails += fail32("neg", neg32_ssa, c, d, -7)
+
+ // denorm-squared should underflow to zero.
+ fails += fail32("*", mul32_ssa, tiny, tiny, 0)
+
+ // but should not underflow in float and in fact is exactly representable.
+ fails += fail64("*", mul64_ssa, dtiny, dtiny, 1.9636373861190906e-90)
+
+ // Intended to create register pressure which forces
+ // asymmetric op into different code paths.
+ aa, ab, ac, ad, ba, bb, bc, bd, ca, cb, cc, cd, da, db, dc, dd := manysub_ssa(1000.0, 100.0, 10.0, 1.0)
+
+ fails += expect64("aa", aa, 11.0)
+ fails += expect64("ab", ab, 900.0)
+ fails += expect64("ac", ac, 990.0)
+ fails += expect64("ad", ad, 999.0)
+
+ fails += expect64("ba", ba, -900.0)
+ fails += expect64("bb", bb, 22.0)
+ fails += expect64("bc", bc, 90.0)
+ fails += expect64("bd", bd, 99.0)
+
+ fails += expect64("ca", ca, -990.0)
+ fails += expect64("cb", cb, -90.0)
+ fails += expect64("cc", cc, 33.0)
+ fails += expect64("cd", cd, 9.0)
+
+ fails += expect64("da", da, -999.0)
+ fails += expect64("db", db, -99.0)
+ fails += expect64("dc", dc, -9.0)
+ fails += expect64("dd", dd, 44.0)
+
+ fails += integer2floatConversions()
+
+ var zero64 float64 = 0.0
+ var one64 float64 = 1.0
+ var inf64 float64 = 1.0 / zero64
+ var nan64 float64 = sub64_ssa(inf64, inf64)
+
+ fails += cmpOpTest("!=", ne64_ssa, nebr64_ssa, ne32_ssa, nebr32_ssa, zero64, one64, inf64, nan64, 0x01111)
+ fails += cmpOpTest("==", eq64_ssa, eqbr64_ssa, eq32_ssa, eqbr32_ssa, zero64, one64, inf64, nan64, 0x10000)
+ fails += cmpOpTest("<=", le64_ssa, lebr64_ssa, le32_ssa, lebr32_ssa, zero64, one64, inf64, nan64, 0x11100)
+ fails += cmpOpTest("<", lt64_ssa, ltbr64_ssa, lt32_ssa, ltbr32_ssa, zero64, one64, inf64, nan64, 0x01100)
+ fails += cmpOpTest(">", gt64_ssa, gtbr64_ssa, gt32_ssa, gtbr32_ssa, zero64, one64, inf64, nan64, 0x00000)
+ fails += cmpOpTest(">=", ge64_ssa, gebr64_ssa, ge32_ssa, gebr32_ssa, zero64, one64, inf64, nan64, 0x10000)
+
+ {
+ lt, le, eq, ne, ge, gt := compares64_ssa(0.0, 1.0, inf64, nan64)
+ fails += expectUint64("lt", lt, 0x0110001000000000)
+ fails += expectUint64("le", le, 0x1110011000100000)
+ fails += expectUint64("eq", eq, 0x1000010000100000)
+ fails += expectUint64("ne", ne, 0x0111101111011111)
+ fails += expectUint64("ge", ge, 0x1000110011100000)
+ fails += expectUint64("gt", gt, 0x0000100011000000)
+ // fmt.Printf("lt=0x%016x, le=0x%016x, eq=0x%016x, ne=0x%016x, ge=0x%016x, gt=0x%016x\n",
+ // lt, le, eq, ne, ge, gt)
+ }
+ {
+ lt, le, eq, ne, ge, gt := compares32_ssa(0.0, 1.0, float32(inf64), float32(nan64))
+ fails += expectUint64("lt", lt, 0x0110001000000000)
+ fails += expectUint64("le", le, 0x1110011000100000)
+ fails += expectUint64("eq", eq, 0x1000010000100000)
+ fails += expectUint64("ne", ne, 0x0111101111011111)
+ fails += expectUint64("ge", ge, 0x1000110011100000)
+ fails += expectUint64("gt", gt, 0x0000100011000000)
+ }
+
+ fails += floatingToIntegerConversionsTest()
+ fails += complexTest128()
+ fails += complexTest64()
+
+ if fails > 0 {
+ fmt.Printf("Saw %v failures\n", fails)
+ panic("Failed.")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go
new file mode 100644
index 0000000..7c7d721
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go
@@ -0,0 +1,214 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This program generates a test to verify that the standard arithmetic
+// operators properly handle some special cases. The test file should be
+// generated with a known working version of go.
+// launch with `go run arithBoundaryGen.go` a file called arithBoundary_ssa.go
+// will be written into the parent directory containing the tests
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "go/format"
+ "io/ioutil"
+ "log"
+ "text/template"
+)
+
+// used for interpolation in a text template
+type tmplData struct {
+ Name, Stype, Symbol string
+}
+
+// used to work around an issue with the mod symbol being
+// interpreted as part of a format string
+func (s tmplData) SymFirst() string {
+ return string(s.Symbol[0])
+}
+
+// ucast casts an unsigned int to the size in s
+func ucast(i uint64, s sizedTestData) uint64 {
+ switch s.name {
+ case "uint32":
+ return uint64(uint32(i))
+ case "uint16":
+ return uint64(uint16(i))
+ case "uint8":
+ return uint64(uint8(i))
+ }
+ return i
+}
+
+// icast casts a signed int to the size in s
+func icast(i int64, s sizedTestData) int64 {
+ switch s.name {
+ case "int32":
+ return int64(int32(i))
+ case "int16":
+ return int64(int16(i))
+ case "int8":
+ return int64(int8(i))
+ }
+ return i
+}
+
+type sizedTestData struct {
+ name string
+ sn string
+ u []uint64
+ i []int64
+}
+
+// values to generate tests. these should include the smallest and largest values, along
+// with any other values that might cause issues. we generate n^2 tests for each size to
+// cover all cases.
+var szs = []sizedTestData{
+ sizedTestData{name: "uint64", sn: "64", u: []uint64{0, 1, 4294967296, 0xffffFFFFffffFFFF}},
+ sizedTestData{name: "int64", sn: "64", i: []int64{-0x8000000000000000, -0x7FFFFFFFFFFFFFFF,
+ -4294967296, -1, 0, 1, 4294967296, 0x7FFFFFFFFFFFFFFE, 0x7FFFFFFFFFFFFFFF}},
+
+ sizedTestData{name: "uint32", sn: "32", u: []uint64{0, 1, 4294967295}},
+ sizedTestData{name: "int32", sn: "32", i: []int64{-0x80000000, -0x7FFFFFFF, -1, 0,
+ 1, 0x7FFFFFFF}},
+
+ sizedTestData{name: "uint16", sn: "16", u: []uint64{0, 1, 65535}},
+ sizedTestData{name: "int16", sn: "16", i: []int64{-32768, -32767, -1, 0, 1, 32766, 32767}},
+
+ sizedTestData{name: "uint8", sn: "8", u: []uint64{0, 1, 255}},
+ sizedTestData{name: "int8", sn: "8", i: []int64{-128, -127, -1, 0, 1, 126, 127}},
+}
+
+type op struct {
+ name, symbol string
+}
+
+// ops that we will be generating tests for
+var ops = []op{op{"add", "+"}, op{"sub", "-"}, op{"div", "/"}, op{"mod", "%%"}, op{"mul", "*"}}
+
+func main() {
+
+ w := new(bytes.Buffer)
+ fmt.Fprintf(w, "package main;\n")
+ fmt.Fprintf(w, "import \"fmt\"\n")
+
+ for _, sz := range []int{64, 32, 16, 8} {
+ fmt.Fprintf(w, "type utd%d struct {\n", sz)
+ fmt.Fprintf(w, " a,b uint%d\n", sz)
+ fmt.Fprintf(w, " add,sub,mul,div,mod uint%d\n", sz)
+ fmt.Fprintf(w, "}\n")
+
+ fmt.Fprintf(w, "type itd%d struct {\n", sz)
+ fmt.Fprintf(w, " a,b int%d\n", sz)
+ fmt.Fprintf(w, " add,sub,mul,div,mod int%d\n", sz)
+ fmt.Fprintf(w, "}\n")
+ }
+
+ // the function being tested
+ testFunc, err := template.New("testFunc").Parse(
+ `//go:noinline
+ func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} {
+ return a {{.SymFirst}} b
+}
+`)
+ if err != nil {
+ panic(err)
+ }
+
+ // generate our functions to be tested
+ for _, s := range szs {
+ for _, o := range ops {
+ fd := tmplData{o.name, s.name, o.symbol}
+ err = testFunc.Execute(w, fd)
+ if err != nil {
+ panic(err)
+ }
+ }
+ }
+
+ // generate the test data
+ for _, s := range szs {
+ if len(s.u) > 0 {
+ fmt.Fprintf(w, "var %s_data []utd%s = []utd%s{", s.name, s.sn, s.sn)
+ for _, i := range s.u {
+ for _, j := range s.u {
+ fmt.Fprintf(w, "utd%s{a: %d, b: %d, add: %d, sub: %d, mul: %d", s.sn, i, j, ucast(i+j, s), ucast(i-j, s), ucast(i*j, s))
+ if j != 0 {
+ fmt.Fprintf(w, ", div: %d, mod: %d", ucast(i/j, s), ucast(i%j, s))
+ }
+ fmt.Fprint(w, "},\n")
+ }
+ }
+ fmt.Fprintf(w, "}\n")
+ } else {
+ // TODO: clean up this duplication
+ fmt.Fprintf(w, "var %s_data []itd%s = []itd%s{", s.name, s.sn, s.sn)
+ for _, i := range s.i {
+ for _, j := range s.i {
+ fmt.Fprintf(w, "itd%s{a: %d, b: %d, add: %d, sub: %d, mul: %d", s.sn, i, j, icast(i+j, s), icast(i-j, s), icast(i*j, s))
+ if j != 0 {
+ fmt.Fprintf(w, ", div: %d, mod: %d", icast(i/j, s), icast(i%j, s))
+ }
+ fmt.Fprint(w, "},\n")
+ }
+ }
+ fmt.Fprintf(w, "}\n")
+ }
+ }
+
+ fmt.Fprintf(w, "var failed bool\n\n")
+ fmt.Fprintf(w, "func main() {\n\n")
+
+ verify, err := template.New("tst").Parse(
+ `if got := {{.Name}}_{{.Stype}}_ssa(v.a, v.b); got != v.{{.Name}} {
+ fmt.Printf("{{.Name}}_{{.Stype}} %d{{.Symbol}}%d = %d, wanted %d\n",v.a,v.b,got,v.{{.Name}})
+ failed = true
+}
+`)
+
+ for _, s := range szs {
+ fmt.Fprintf(w, "for _, v := range %s_data {\n", s.name)
+
+ for _, o := range ops {
+ // avoid generating tests that divide by zero
+ if o.name == "div" || o.name == "mod" {
+ fmt.Fprint(w, "if v.b != 0 {")
+ }
+
+ err = verify.Execute(w, tmplData{o.name, s.name, o.symbol})
+
+ if o.name == "div" || o.name == "mod" {
+ fmt.Fprint(w, "\n}\n")
+ }
+
+ if err != nil {
+ panic(err)
+ }
+
+ }
+ fmt.Fprint(w, " }\n")
+ }
+
+ fmt.Fprintf(w, `if failed {
+ panic("tests failed")
+ }
+`)
+ fmt.Fprintf(w, "}\n")
+
+ // gofmt result
+ b := w.Bytes()
+ src, err := format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", b)
+ panic(err)
+ }
+
+ // write to file
+ err = ioutil.WriteFile("../arithBoundary_ssa.go", src, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go b/src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go
new file mode 100644
index 0000000..34e54ad
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go
@@ -0,0 +1,294 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This program generates a test to verify that the standard arithmetic
+// operators properly handle const cases. The test file should be
+// generated with a known working version of go.
+// launch with `go run arithConstGen.go` a file called arithConst_ssa.go
+// will be written into the parent directory containing the tests
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "go/format"
+ "io/ioutil"
+ "log"
+ "strings"
+ "text/template"
+)
+
+type op struct {
+ name, symbol string
+}
+type szD struct {
+ name string
+ sn string
+ u []uint64
+ i []int64
+}
+
+var szs []szD = []szD{
+ szD{name: "uint64", sn: "64", u: []uint64{0, 1, 4294967296, 0xffffFFFFffffFFFF}},
+ szD{name: "int64", sn: "64", i: []int64{-0x8000000000000000, -0x7FFFFFFFFFFFFFFF,
+ -4294967296, -1, 0, 1, 4294967296, 0x7FFFFFFFFFFFFFFE, 0x7FFFFFFFFFFFFFFF}},
+
+ szD{name: "uint32", sn: "32", u: []uint64{0, 1, 4294967295}},
+ szD{name: "int32", sn: "32", i: []int64{-0x80000000, -0x7FFFFFFF, -1, 0,
+ 1, 0x7FFFFFFF}},
+
+ szD{name: "uint16", sn: "16", u: []uint64{0, 1, 65535}},
+ szD{name: "int16", sn: "16", i: []int64{-32768, -32767, -1, 0, 1, 32766, 32767}},
+
+ szD{name: "uint8", sn: "8", u: []uint64{0, 1, 255}},
+ szD{name: "int8", sn: "8", i: []int64{-128, -127, -1, 0, 1, 126, 127}},
+}
+
+var ops []op = []op{op{"add", "+"}, op{"sub", "-"}, op{"div", "/"}, op{"mul", "*"},
+ op{"lsh", "<<"}, op{"rsh", ">>"}}
+
+// compute the result of i op j, cast as type t.
+func ansU(i, j uint64, t, op string) string {
+ var ans uint64
+ switch op {
+ case "+":
+ ans = i + j
+ case "-":
+ ans = i - j
+ case "*":
+ ans = i * j
+ case "/":
+ if j != 0 {
+ ans = i / j
+ }
+ case "<<":
+ ans = i << j
+ case ">>":
+ ans = i >> j
+ }
+ switch t {
+ case "uint32":
+ ans = uint64(uint32(ans))
+ case "uint16":
+ ans = uint64(uint16(ans))
+ case "uint8":
+ ans = uint64(uint8(ans))
+ }
+ return fmt.Sprintf("%d", ans)
+}
+
+// compute the result of i op j, cast as type t.
+func ansS(i, j int64, t, op string) string {
+ var ans int64
+ switch op {
+ case "+":
+ ans = i + j
+ case "-":
+ ans = i - j
+ case "*":
+ ans = i * j
+ case "/":
+ if j != 0 {
+ ans = i / j
+ }
+ case "<<":
+ ans = i << uint64(j)
+ case ">>":
+ ans = i >> uint64(j)
+ }
+ switch t {
+ case "int32":
+ ans = int64(int32(ans))
+ case "int16":
+ ans = int64(int16(ans))
+ case "int8":
+ ans = int64(int8(ans))
+ }
+ return fmt.Sprintf("%d", ans)
+}
+
+func main() {
+
+ w := new(bytes.Buffer)
+
+ fmt.Fprintf(w, "package main;\n")
+ fmt.Fprintf(w, "import \"fmt\"\n")
+
+ fncCnst1, err := template.New("fnc").Parse(
+ `//go:noinline
+ func {{.Name}}_{{.Type_}}_{{.FNumber}}_ssa(a {{.Type_}}) {{.Type_}} {
+ return a {{.Symbol}} {{.Number}}
+}
+`)
+ if err != nil {
+ panic(err)
+ }
+ fncCnst2, err := template.New("fnc").Parse(
+ `//go:noinline
+ func {{.Name}}_{{.FNumber}}_{{.Type_}}_ssa(a {{.Type_}}) {{.Type_}} {
+ return {{.Number}} {{.Symbol}} a
+}
+
+`)
+ if err != nil {
+ panic(err)
+ }
+
+ type fncData struct {
+ Name, Type_, Symbol, FNumber, Number string
+ }
+
+ for _, s := range szs {
+ for _, o := range ops {
+ fd := fncData{o.name, s.name, o.symbol, "", ""}
+
+ // unsigned test cases
+ if len(s.u) > 0 {
+ for _, i := range s.u {
+ fd.Number = fmt.Sprintf("%d", i)
+ fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1)
+
+ // avoid division by zero
+ if o.name != "div" || i != 0 {
+ fncCnst1.Execute(w, fd)
+ }
+
+ fncCnst2.Execute(w, fd)
+ }
+ }
+
+ // signed test cases
+ if len(s.i) > 0 {
+ // don't generate tests for shifts by signed integers
+ if o.name == "lsh" || o.name == "rsh" {
+ continue
+ }
+ for _, i := range s.i {
+ fd.Number = fmt.Sprintf("%d", i)
+ fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1)
+
+ // avoid division by zero
+ if o.name != "div" || i != 0 {
+ fncCnst1.Execute(w, fd)
+ }
+ fncCnst2.Execute(w, fd)
+ }
+ }
+ }
+ }
+
+ fmt.Fprintf(w, "var failed bool\n\n")
+ fmt.Fprintf(w, "func main() {\n\n")
+
+ vrf1, _ := template.New("vrf1").Parse(`
+ if got := {{.Name}}_{{.FNumber}}_{{.Type_}}_ssa({{.Input}}); got != {{.Ans}} {
+ fmt.Printf("{{.Name}}_{{.Type_}} {{.Number}}{{.Symbol}}{{.Input}} = %d, wanted {{.Ans}}\n",got)
+ failed = true
+ }
+`)
+
+ vrf2, _ := template.New("vrf2").Parse(`
+ if got := {{.Name}}_{{.Type_}}_{{.FNumber}}_ssa({{.Input}}); got != {{.Ans}} {
+ fmt.Printf("{{.Name}}_{{.Type_}} {{.Input}}{{.Symbol}}{{.Number}} = %d, wanted {{.Ans}}\n",got)
+ failed = true
+ }
+`)
+
+ type cfncData struct {
+ Name, Type_, Symbol, FNumber, Number string
+ Ans, Input string
+ }
+ for _, s := range szs {
+ if len(s.u) > 0 {
+ for _, o := range ops {
+ fd := cfncData{o.name, s.name, o.symbol, "", "", "", ""}
+ for _, i := range s.u {
+ fd.Number = fmt.Sprintf("%d", i)
+ fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1)
+
+ // unsigned
+ for _, j := range s.u {
+
+ if o.name != "div" || j != 0 {
+ fd.Ans = ansU(i, j, s.name, o.symbol)
+ fd.Input = fmt.Sprintf("%d", j)
+ err = vrf1.Execute(w, fd)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ if o.name != "div" || i != 0 {
+ fd.Ans = ansU(j, i, s.name, o.symbol)
+ fd.Input = fmt.Sprintf("%d", j)
+ err = vrf2.Execute(w, fd)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ }
+ }
+
+ }
+ }
+
+ // signed
+ if len(s.i) > 0 {
+ for _, o := range ops {
+ // don't generate tests for shifts by signed integers
+ if o.name == "lsh" || o.name == "rsh" {
+ continue
+ }
+ fd := cfncData{o.name, s.name, o.symbol, "", "", "", ""}
+ for _, i := range s.i {
+ fd.Number = fmt.Sprintf("%d", i)
+ fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1)
+ for _, j := range s.i {
+ if o.name != "div" || j != 0 {
+ fd.Ans = ansS(i, j, s.name, o.symbol)
+ fd.Input = fmt.Sprintf("%d", j)
+ err = vrf1.Execute(w, fd)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ if o.name != "div" || i != 0 {
+ fd.Ans = ansS(j, i, s.name, o.symbol)
+ fd.Input = fmt.Sprintf("%d", j)
+ err = vrf2.Execute(w, fd)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ }
+ }
+
+ }
+ }
+ }
+
+ fmt.Fprintf(w, `if failed {
+ panic("tests failed")
+ }
+`)
+ fmt.Fprintf(w, "}\n")
+
+ // gofmt result
+ b := w.Bytes()
+ src, err := format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", b)
+ panic(err)
+ }
+
+ // write to file
+ err = ioutil.WriteFile("../arithConst_ssa.go", src, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/gen/copyGen.go b/src/cmd/compile/internal/gc/testdata/gen/copyGen.go
new file mode 100644
index 0000000..a699fac
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/gen/copyGen.go
@@ -0,0 +1,93 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "go/format"
+ "io/ioutil"
+ "log"
+)
+
+// This program generates tests to verify that copying operations
+// copy the data they are supposed to and clobber no adjacent values.
+
+// run as `go run copyGen.go`. A file called copy_ssa.go
+// will be written into the parent directory containing the tests.
+
+var sizes = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 23, 24, 25, 31, 32, 33, 63, 64, 65, 1023, 1024, 1025, 1024 + 7, 1024 + 8, 1024 + 9, 1024 + 15, 1024 + 16, 1024 + 17}
+
+func main() {
+ w := new(bytes.Buffer)
+ fmt.Fprintf(w, "// run\n")
+ fmt.Fprintf(w, "// autogenerated from gen/copyGen.go - do not edit!\n")
+ fmt.Fprintf(w, "package main\n")
+ fmt.Fprintf(w, "import \"fmt\"\n")
+
+ for _, s := range sizes {
+ // type for test
+ fmt.Fprintf(w, "type T%d struct {\n", s)
+ fmt.Fprintf(w, " pre [8]byte\n")
+ fmt.Fprintf(w, " mid [%d]byte\n", s)
+ fmt.Fprintf(w, " post [8]byte\n")
+ fmt.Fprintf(w, "}\n")
+
+ // function being tested
+ fmt.Fprintf(w, "func t%dcopy_ssa(y, x *[%d]byte) {\n", s, s)
+ fmt.Fprintf(w, " switch{}\n")
+ fmt.Fprintf(w, " *y = *x\n")
+ fmt.Fprintf(w, "}\n")
+
+ // testing harness
+ fmt.Fprintf(w, "func testCopy%d() {\n", s)
+ fmt.Fprintf(w, " a := T%d{[8]byte{201, 202, 203, 204, 205, 206, 207, 208},[%d]byte{", s, s)
+ for i := 0; i < s; i++ {
+ fmt.Fprintf(w, "%d,", i%100)
+ }
+ fmt.Fprintf(w, "},[8]byte{211, 212, 213, 214, 215, 216, 217, 218}}\n")
+ fmt.Fprintf(w, " x := [%d]byte{", s)
+ for i := 0; i < s; i++ {
+ fmt.Fprintf(w, "%d,", 100+i%100)
+ }
+ fmt.Fprintf(w, "}\n")
+ fmt.Fprintf(w, " t%dcopy_ssa(&a.mid, &x)\n", s)
+ fmt.Fprintf(w, " want := T%d{[8]byte{201, 202, 203, 204, 205, 206, 207, 208},[%d]byte{", s, s)
+ for i := 0; i < s; i++ {
+ fmt.Fprintf(w, "%d,", 100+i%100)
+ }
+ fmt.Fprintf(w, "},[8]byte{211, 212, 213, 214, 215, 216, 217, 218}}\n")
+ fmt.Fprintf(w, " if a != want {\n")
+ fmt.Fprintf(w, " fmt.Printf(\"t%dcopy got=%%v, want %%v\\n\", a, want)\n", s)
+ fmt.Fprintf(w, " failed=true\n")
+ fmt.Fprintf(w, " }\n")
+ fmt.Fprintf(w, "}\n")
+ }
+
+ // boilerplate at end
+ fmt.Fprintf(w, "var failed bool\n")
+ fmt.Fprintf(w, "func main() {\n")
+ for _, s := range sizes {
+ fmt.Fprintf(w, " testCopy%d()\n", s)
+ }
+ fmt.Fprintf(w, " if failed {\n")
+ fmt.Fprintf(w, " panic(\"failed\")\n")
+ fmt.Fprintf(w, " }\n")
+ fmt.Fprintf(w, "}\n")
+
+ // gofmt result
+ b := w.Bytes()
+ src, err := format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", b)
+ panic(err)
+ }
+
+ // write to file
+ err = ioutil.WriteFile("../copy_ssa.go", src, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/gen/zeroGen.go b/src/cmd/compile/internal/gc/testdata/gen/zeroGen.go
new file mode 100644
index 0000000..90e8029
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/gen/zeroGen.go
@@ -0,0 +1,88 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "go/format"
+ "io/ioutil"
+ "log"
+)
+
+// This program generates tests to verify that zeroing operations
+// zero the data they are supposed to and clobber no adjacent values.
+
+// run as `go run zeroGen.go`. A file called zero_ssa.go
+// will be written into the parent directory containing the tests.
+
+var sizes = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 23, 24, 25, 31, 32, 33, 63, 64, 65, 1023, 1024, 1025}
+
+func main() {
+ w := new(bytes.Buffer)
+ fmt.Fprintf(w, "// run\n")
+ fmt.Fprintf(w, "// autogenerated from gen/zeroGen.go - do not edit!\n")
+ fmt.Fprintf(w, "package main\n")
+ fmt.Fprintf(w, "import \"fmt\"\n")
+
+ for _, s := range sizes {
+ // type for test
+ fmt.Fprintf(w, "type T%d struct {\n", s)
+ fmt.Fprintf(w, " pre [8]byte\n")
+ fmt.Fprintf(w, " mid [%d]byte\n", s)
+ fmt.Fprintf(w, " post [8]byte\n")
+ fmt.Fprintf(w, "}\n")
+
+ // function being tested
+ fmt.Fprintf(w, "func zero%d_ssa(x *[%d]byte) {\n", s, s)
+ fmt.Fprintf(w, " switch{}\n")
+ fmt.Fprintf(w, " *x = [%d]byte{}\n", s)
+ fmt.Fprintf(w, "}\n")
+
+ // testing harness
+ fmt.Fprintf(w, "func testZero%d() {\n", s)
+ fmt.Fprintf(w, " a := T%d{[8]byte{255,255,255,255,255,255,255,255},[%d]byte{", s, s)
+ for i := 0; i < s; i++ {
+ fmt.Fprintf(w, "255,")
+ }
+ fmt.Fprintf(w, "},[8]byte{255,255,255,255,255,255,255,255}}\n")
+ fmt.Fprintf(w, " zero%d_ssa(&a.mid)\n", s)
+ fmt.Fprintf(w, " want := T%d{[8]byte{255,255,255,255,255,255,255,255},[%d]byte{", s, s)
+ for i := 0; i < s; i++ {
+ fmt.Fprintf(w, "0,")
+ }
+ fmt.Fprintf(w, "},[8]byte{255,255,255,255,255,255,255,255}}\n")
+ fmt.Fprintf(w, " if a != want {\n")
+ fmt.Fprintf(w, " fmt.Printf(\"zero%d got=%%v, want %%v\\n\", a, want)\n", s)
+ fmt.Fprintf(w, " failed=true\n")
+ fmt.Fprintf(w, " }\n")
+ fmt.Fprintf(w, "}\n")
+ }
+
+ // boilerplate at end
+ fmt.Fprintf(w, "var failed bool\n")
+ fmt.Fprintf(w, "func main() {\n")
+ for _, s := range sizes {
+ fmt.Fprintf(w, " testZero%d()\n", s)
+ }
+ fmt.Fprintf(w, " if failed {\n")
+ fmt.Fprintf(w, " panic(\"failed\")\n")
+ fmt.Fprintf(w, " }\n")
+ fmt.Fprintf(w, "}\n")
+
+ // gofmt result
+ b := w.Bytes()
+ src, err := format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", b)
+ panic(err)
+ }
+
+ // write to file
+ err = ioutil.WriteFile("../zero_ssa.go", src, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go
new file mode 100644
index 0000000..e0b0b4d
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go
@@ -0,0 +1,117 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests load/store ordering
+
+package main
+
+import "fmt"
+
+// testLoadStoreOrder tests for reordering of stores/loads.
+func testLoadStoreOrder() {
+ z := uint32(1000)
+ if testLoadStoreOrder_ssa(&z, 100) == 0 {
+ println("testLoadStoreOrder failed")
+ failed = true
+ }
+}
+func testLoadStoreOrder_ssa(z *uint32, prec uint) int {
+ switch {
+ }
+ old := *z // load
+ *z = uint32(prec) // store
+ if *z < old { // load
+ return 1
+ }
+ return 0
+}
+
+func testStoreSize() {
+ a := [4]uint16{11, 22, 33, 44}
+ testStoreSize_ssa(&a[0], &a[2], 77)
+ want := [4]uint16{77, 22, 33, 44}
+ if a != want {
+ fmt.Println("testStoreSize failed. want =", want, ", got =", a)
+ failed = true
+ }
+}
+func testStoreSize_ssa(p *uint16, q *uint16, v uint32) {
+ switch {
+ }
+ // Test to make sure that (Store ptr (Trunc32to16 val) mem)
+ // does not end up as a 32-bit store. It must stay a 16 bit store
+ // even when Trunc32to16 is rewritten to be a nop.
+ // To ensure that we get rewrite the Trunc32to16 before
+ // we rewrite the Store, we force the truncate into an
+ // earlier basic block by using it on both branches.
+ w := uint16(v)
+ if p != nil {
+ *p = w
+ } else {
+ *q = w
+ }
+}
+
+var failed = false
+
+func testExtStore_ssa(p *byte, b bool) int {
+ switch {
+ }
+ x := *p
+ *p = 7
+ if b {
+ return int(x)
+ }
+ return 0
+}
+
+func testExtStore() {
+ const start = 8
+ var b byte = start
+ if got := testExtStore_ssa(&b, true); got != start {
+ fmt.Println("testExtStore failed. want =", start, ", got =", got)
+ failed = true
+ }
+}
+
+var b int
+
+// testDeadStorePanic_ssa ensures that we don't optimize away stores
+// that could be read by after recover(). Modeled after fixedbugs/issue1304.
+func testDeadStorePanic_ssa(a int) (r int) {
+ switch {
+ }
+ defer func() {
+ recover()
+ r = a
+ }()
+ a = 2 // store
+ b := a - a // optimized to zero
+ c := 4
+ a = c / b // store, but panics
+ a = 3 // store
+ r = a
+ return
+}
+
+func testDeadStorePanic() {
+ if want, got := 2, testDeadStorePanic_ssa(1); want != got {
+ fmt.Println("testDeadStorePanic failed. want =", want, ", got =", got)
+ failed = true
+ }
+}
+
+func main() {
+
+ testLoadStoreOrder()
+ testStoreSize()
+ testExtStore()
+ testDeadStorePanic()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/map_ssa.go b/src/cmd/compile/internal/gc/testdata/map_ssa.go
new file mode 100644
index 0000000..4a46600
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/map_ssa.go
@@ -0,0 +1,45 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// map_ssa.go tests map operations.
+package main
+
+import "fmt"
+
+var failed = false
+
+//go:noinline
+func lenMap_ssa(v map[int]int) int {
+ return len(v)
+}
+
+func testLenMap() {
+
+ v := make(map[int]int)
+ v[0] = 0
+ v[1] = 0
+ v[2] = 0
+
+ if want, got := 3, lenMap_ssa(v); got != want {
+ fmt.Printf("expected len(map) = %d, got %d", want, got)
+ failed = true
+ }
+}
+
+func testLenNilMap() {
+
+ var v map[int]int
+ if want, got := 0, lenMap_ssa(v); got != want {
+ fmt.Printf("expected len(nil) = %d, got %d", want, got)
+ failed = true
+ }
+}
+func main() {
+ testLenMap()
+ testLenNilMap()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/phi_ssa.go b/src/cmd/compile/internal/gc/testdata/phi_ssa.go
new file mode 100644
index 0000000..e855070
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/phi_ssa.go
@@ -0,0 +1,103 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+// Test to make sure spills of cast-shortened values
+// don't end up spilling the pre-shortened size instead
+// of the post-shortened size.
+
+import (
+ "fmt"
+ "runtime"
+)
+
+// unfoldable true
+var true_ = true
+
+var data1 [26]int32
+var data2 [26]int64
+
+func init() {
+ for i := 0; i < 26; i++ {
+ // If we spill all 8 bytes of this datum, the 1 in the high-order 4 bytes
+ // will overwrite some other variable in the stack frame.
+ data2[i] = 0x100000000
+ }
+}
+
+func foo() int32 {
+ var a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z int32
+ if true_ {
+ a = data1[0]
+ b = data1[1]
+ c = data1[2]
+ d = data1[3]
+ e = data1[4]
+ f = data1[5]
+ g = data1[6]
+ h = data1[7]
+ i = data1[8]
+ j = data1[9]
+ k = data1[10]
+ l = data1[11]
+ m = data1[12]
+ n = data1[13]
+ o = data1[14]
+ p = data1[15]
+ q = data1[16]
+ r = data1[17]
+ s = data1[18]
+ t = data1[19]
+ u = data1[20]
+ v = data1[21]
+ w = data1[22]
+ x = data1[23]
+ y = data1[24]
+ z = data1[25]
+ } else {
+ a = int32(data2[0])
+ b = int32(data2[1])
+ c = int32(data2[2])
+ d = int32(data2[3])
+ e = int32(data2[4])
+ f = int32(data2[5])
+ g = int32(data2[6])
+ h = int32(data2[7])
+ i = int32(data2[8])
+ j = int32(data2[9])
+ k = int32(data2[10])
+ l = int32(data2[11])
+ m = int32(data2[12])
+ n = int32(data2[13])
+ o = int32(data2[14])
+ p = int32(data2[15])
+ q = int32(data2[16])
+ r = int32(data2[17])
+ s = int32(data2[18])
+ t = int32(data2[19])
+ u = int32(data2[20])
+ v = int32(data2[21])
+ w = int32(data2[22])
+ x = int32(data2[23])
+ y = int32(data2[24])
+ z = int32(data2[25])
+ }
+ // Lots of phis of the form phi(int32,int64) of type int32 happen here.
+ // Some will be stack phis. For those stack phis, make sure the spill
+ // of the second argument uses the phi's width (4 bytes), not its width
+ // (8 bytes). Otherwise, a random stack slot gets clobbered.
+
+ runtime.Gosched()
+ return a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y + z
+}
+
+func main() {
+ want := int32(0)
+ got := foo()
+ if got != want {
+ fmt.Printf("want %d, got %d\n", want, got)
+ panic("bad")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/regalloc_ssa.go b/src/cmd/compile/internal/gc/testdata/regalloc_ssa.go
new file mode 100644
index 0000000..f752692
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/regalloc_ssa.go
@@ -0,0 +1,57 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests phi implementation
+
+package main
+
+func phiOverwrite_ssa() int {
+ var n int
+ for i := 0; i < 10; i++ {
+ if i == 6 {
+ break
+ }
+ n = i
+ }
+ return n
+}
+
+func phiOverwrite() {
+ want := 5
+ got := phiOverwrite_ssa()
+ if got != want {
+ println("phiOverwrite_ssa()=", want, ", got", got)
+ failed = true
+ }
+}
+
+func phiOverwriteBig_ssa() int {
+ var a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z int
+ a = 1
+ for idx := 0; idx < 26; idx++ {
+ a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z = b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a
+ }
+ return a*1 + b*2 + c*3 + d*4 + e*5 + f*6 + g*7 + h*8 + i*9 + j*10 + k*11 + l*12 + m*13 + n*14 + o*15 + p*16 + q*17 + r*18 + s*19 + t*20 + u*21 + v*22 + w*23 + x*24 + y*25 + z*26
+}
+
+func phiOverwriteBig() {
+ want := 1
+ got := phiOverwriteBig_ssa()
+ if got != want {
+ println("phiOverwriteBig_ssa()=", want, ", got", got)
+ failed = true
+ }
+}
+
+var failed = false
+
+func main() {
+ phiOverwrite()
+ phiOverwriteBig()
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/short_ssa.go b/src/cmd/compile/internal/gc/testdata/short_ssa.go
new file mode 100644
index 0000000..fcec1ba
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/short_ssa.go
@@ -0,0 +1,60 @@
+// run
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests short circuiting.
+
+package main
+
+func and_ssa(arg1, arg2 bool) bool {
+ return arg1 && rightCall(arg2)
+}
+
+func or_ssa(arg1, arg2 bool) bool {
+ return arg1 || rightCall(arg2)
+}
+
+var rightCalled bool
+
+//go:noinline
+func rightCall(v bool) bool {
+ rightCalled = true
+ return v
+ panic("unreached")
+}
+
+func testAnd(arg1, arg2, wantRes bool) { testShortCircuit("AND", arg1, arg2, and_ssa, arg1, wantRes) }
+func testOr(arg1, arg2, wantRes bool) { testShortCircuit("OR", arg1, arg2, or_ssa, !arg1, wantRes) }
+
+func testShortCircuit(opName string, arg1, arg2 bool, fn func(bool, bool) bool, wantRightCall, wantRes bool) {
+ rightCalled = false
+ got := fn(arg1, arg2)
+ if rightCalled != wantRightCall {
+ println("failed for", arg1, opName, arg2, "; rightCalled=", rightCalled, "want=", wantRightCall)
+ failed = true
+ }
+ if wantRes != got {
+ println("failed for", arg1, opName, arg2, "; res=", got, "want=", wantRes)
+ failed = true
+ }
+}
+
+var failed = false
+
+func main() {
+ testAnd(false, false, false)
+ testAnd(false, true, false)
+ testAnd(true, false, false)
+ testAnd(true, true, true)
+
+ testOr(false, false, false)
+ testOr(false, true, true)
+ testOr(true, false, true)
+ testOr(true, true, true)
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go
new file mode 100644
index 0000000..a949fbc
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go
@@ -0,0 +1,161 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// string_ssa.go tests string operations.
+package main
+
+var failed = false
+
+//go:noinline
+func testStringSlice1_ssa(a string, i, j int) string {
+ return a[i:]
+}
+
+//go:noinline
+func testStringSlice2_ssa(a string, i, j int) string {
+ return a[:j]
+}
+
+//go:noinline
+func testStringSlice12_ssa(a string, i, j int) string {
+ return a[i:j]
+}
+
+func testStringSlice() {
+ tests := [...]struct {
+ fn func(string, int, int) string
+ s string
+ low, high int
+ want string
+ }{
+ // -1 means the value is not used.
+ {testStringSlice1_ssa, "foobar", 0, -1, "foobar"},
+ {testStringSlice1_ssa, "foobar", 3, -1, "bar"},
+ {testStringSlice1_ssa, "foobar", 6, -1, ""},
+ {testStringSlice2_ssa, "foobar", -1, 0, ""},
+ {testStringSlice2_ssa, "foobar", -1, 3, "foo"},
+ {testStringSlice2_ssa, "foobar", -1, 6, "foobar"},
+ {testStringSlice12_ssa, "foobar", 0, 6, "foobar"},
+ {testStringSlice12_ssa, "foobar", 0, 0, ""},
+ {testStringSlice12_ssa, "foobar", 6, 6, ""},
+ {testStringSlice12_ssa, "foobar", 1, 5, "ooba"},
+ {testStringSlice12_ssa, "foobar", 3, 3, ""},
+ {testStringSlice12_ssa, "", 0, 0, ""},
+ }
+
+ for i, t := range tests {
+ if got := t.fn(t.s, t.low, t.high); t.want != got {
+ println("#", i, " ", t.s, "[", t.low, ":", t.high, "] = ", got, " want ", t.want)
+ failed = true
+ }
+ }
+}
+
+type prefix struct {
+ prefix string
+}
+
+func (p *prefix) slice_ssa() {
+ p.prefix = p.prefix[:3]
+}
+
+func testStructSlice() {
+ switch {
+ }
+ p := &prefix{"prefix"}
+ p.slice_ssa()
+ if "pre" != p.prefix {
+ println("wrong field slice: wanted %s got %s", "pre", p.prefix)
+ failed = true
+ }
+}
+
+func testStringSlicePanic() {
+ defer func() {
+ if r := recover(); r != nil {
+ println("paniced as expected")
+ }
+ }()
+
+ str := "foobar"
+ println("got ", testStringSlice12_ssa(str, 3, 9))
+ println("expected to panic, but didn't")
+ failed = true
+}
+
+const _Accuracy_name = "BelowExactAbove"
+
+var _Accuracy_index = [...]uint8{0, 5, 10, 15}
+
+//go:noinline
+func testSmallIndexType_ssa(i int) string {
+ return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]]
+}
+
+func testSmallIndexType() {
+ tests := []struct {
+ i int
+ want string
+ }{
+ {0, "Below"},
+ {1, "Exact"},
+ {2, "Above"},
+ }
+
+ for i, t := range tests {
+ if got := testSmallIndexType_ssa(t.i); got != t.want {
+ println("#", i, "got ", got, ", wanted", t.want)
+ failed = true
+ }
+ }
+}
+
+//go:noinline
+func testStringElem_ssa(s string, i int) byte {
+ return s[i]
+}
+
+func testStringElem() {
+ tests := []struct {
+ s string
+ i int
+ n byte
+ }{
+ {"foobar", 3, 98},
+ {"foobar", 0, 102},
+ {"foobar", 5, 114},
+ }
+ for _, t := range tests {
+ if got := testStringElem_ssa(t.s, t.i); got != t.n {
+ print("testStringElem \"", t.s, "\"[", t.i, "]=", got, ", wanted ", t.n, "\n")
+ failed = true
+ }
+ }
+}
+
+//go:noinline
+func testStringElemConst_ssa(i int) byte {
+ s := "foobar"
+ return s[i]
+}
+
+func testStringElemConst() {
+ if got := testStringElemConst_ssa(3); got != 98 {
+ println("testStringElemConst=", got, ", wanted 98")
+ failed = true
+ }
+}
+
+func main() {
+ testStringSlice()
+ testStringSlicePanic()
+ testStructSlice()
+ testSmallIndexType()
+ testStringElem()
+ testStringElemConst()
+
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go b/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go
new file mode 100644
index 0000000..d074eb1
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go
@@ -0,0 +1,148 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "runtime"
+ "unsafe"
+)
+
+// global pointer slot
+var a *[8]uint
+
+// unfoldable true
+var b = true
+
+// Test to make sure that a pointer value which is alive
+// across a call is retained, even when there are matching
+// conversions to/from uintptr around the call.
+// We arrange things very carefully to have to/from
+// conversions on either side of the call which cannot be
+// combined with any other conversions.
+func f_ssa() *[8]uint {
+ // Make x a uintptr pointing to where a points.
+ var x uintptr
+ if b {
+ x = uintptr(unsafe.Pointer(a))
+ } else {
+ x = 0
+ }
+ // Clobber the global pointer. The only live ref
+ // to the allocated object is now x.
+ a = nil
+
+ // Convert to pointer so it should hold
+ // the object live across GC call.
+ p := unsafe.Pointer(x)
+
+ // Call gc.
+ runtime.GC()
+
+ // Convert back to uintptr.
+ y := uintptr(p)
+
+ // Mess with y so that the subsequent cast
+ // to unsafe.Pointer can't be combined with the
+ // uintptr cast above.
+ var z uintptr
+ if b {
+ z = y
+ } else {
+ z = 0
+ }
+ return (*[8]uint)(unsafe.Pointer(z))
+}
+
+// g_ssa is the same as f_ssa, but with a bit of pointer
+// arithmetic for added insanity.
+func g_ssa() *[7]uint {
+ // Make x a uintptr pointing to where a points.
+ var x uintptr
+ if b {
+ x = uintptr(unsafe.Pointer(a))
+ } else {
+ x = 0
+ }
+ // Clobber the global pointer. The only live ref
+ // to the allocated object is now x.
+ a = nil
+
+ // Offset x by one int.
+ x += unsafe.Sizeof(int(0))
+
+ // Convert to pointer so it should hold
+ // the object live across GC call.
+ p := unsafe.Pointer(x)
+
+ // Call gc.
+ runtime.GC()
+
+ // Convert back to uintptr.
+ y := uintptr(p)
+
+ // Mess with y so that the subsequent cast
+ // to unsafe.Pointer can't be combined with the
+ // uintptr cast above.
+ var z uintptr
+ if b {
+ z = y
+ } else {
+ z = 0
+ }
+ return (*[7]uint)(unsafe.Pointer(z))
+}
+
+func testf() {
+ a = new([8]uint)
+ for i := 0; i < 8; i++ {
+ a[i] = 0xabcd
+ }
+ c := f_ssa()
+ for i := 0; i < 8; i++ {
+ if c[i] != 0xabcd {
+ fmt.Printf("%d:%x\n", i, c[i])
+ panic("bad c")
+ }
+ }
+}
+
+func testg() {
+ a = new([8]uint)
+ for i := 0; i < 8; i++ {
+ a[i] = 0xabcd
+ }
+ c := g_ssa()
+ for i := 0; i < 7; i++ {
+ if c[i] != 0xabcd {
+ fmt.Printf("%d:%x\n", i, c[i])
+ panic("bad c")
+ }
+ }
+}
+
+func alias_ssa(ui64 *uint64, ui32 *uint32) uint32 {
+ *ui32 = 0xffffffff
+ *ui64 = 0 // store
+ ret := *ui32 // load from same address, should be zero
+ *ui64 = 0xffffffffffffffff // store
+ return ret
+}
+func testdse() {
+ x := int64(-1)
+ // construct two pointers that alias one another
+ ui64 := (*uint64)(unsafe.Pointer(&x))
+ ui32 := (*uint32)(unsafe.Pointer(&x))
+ if want, got := uint32(0), alias_ssa(ui64, ui32); got != want {
+ fmt.Printf("alias_ssa: wanted %d, got %d\n", want, got)
+ panic("alias_ssa")
+ }
+}
+
+func main() {
+ testf()
+ testg()
+ testdse()
+}
diff --git a/src/cmd/compile/internal/gc/testdata/zero_ssa.go b/src/cmd/compile/internal/gc/testdata/zero_ssa.go
new file mode 100644
index 0000000..0ec883b
--- /dev/null
+++ b/src/cmd/compile/internal/gc/testdata/zero_ssa.go
@@ -0,0 +1,563 @@
+// run
+// autogenerated from gen/zeroGen.go - do not edit!
+package main
+
+import "fmt"
+
+type T1 struct {
+ pre [8]byte
+ mid [1]byte
+ post [8]byte
+}
+
+func zero1_ssa(x *[1]byte) {
+ switch {
+ }
+ *x = [1]byte{}
+}
+func testZero1() {
+ a := T1{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1]byte{255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero1_ssa(&a.mid)
+ want := T1{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1]byte{0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero1 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T2 struct {
+ pre [8]byte
+ mid [2]byte
+ post [8]byte
+}
+
+func zero2_ssa(x *[2]byte) {
+ switch {
+ }
+ *x = [2]byte{}
+}
+func testZero2() {
+ a := T2{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [2]byte{255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero2_ssa(&a.mid)
+ want := T2{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [2]byte{0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero2 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T3 struct {
+ pre [8]byte
+ mid [3]byte
+ post [8]byte
+}
+
+func zero3_ssa(x *[3]byte) {
+ switch {
+ }
+ *x = [3]byte{}
+}
+func testZero3() {
+ a := T3{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [3]byte{255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero3_ssa(&a.mid)
+ want := T3{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [3]byte{0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero3 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T4 struct {
+ pre [8]byte
+ mid [4]byte
+ post [8]byte
+}
+
+func zero4_ssa(x *[4]byte) {
+ switch {
+ }
+ *x = [4]byte{}
+}
+func testZero4() {
+ a := T4{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [4]byte{255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero4_ssa(&a.mid)
+ want := T4{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [4]byte{0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero4 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T5 struct {
+ pre [8]byte
+ mid [5]byte
+ post [8]byte
+}
+
+func zero5_ssa(x *[5]byte) {
+ switch {
+ }
+ *x = [5]byte{}
+}
+func testZero5() {
+ a := T5{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [5]byte{255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero5_ssa(&a.mid)
+ want := T5{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [5]byte{0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero5 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T6 struct {
+ pre [8]byte
+ mid [6]byte
+ post [8]byte
+}
+
+func zero6_ssa(x *[6]byte) {
+ switch {
+ }
+ *x = [6]byte{}
+}
+func testZero6() {
+ a := T6{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [6]byte{255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero6_ssa(&a.mid)
+ want := T6{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [6]byte{0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero6 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T7 struct {
+ pre [8]byte
+ mid [7]byte
+ post [8]byte
+}
+
+func zero7_ssa(x *[7]byte) {
+ switch {
+ }
+ *x = [7]byte{}
+}
+func testZero7() {
+ a := T7{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [7]byte{255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero7_ssa(&a.mid)
+ want := T7{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [7]byte{0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero7 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T8 struct {
+ pre [8]byte
+ mid [8]byte
+ post [8]byte
+}
+
+func zero8_ssa(x *[8]byte) {
+ switch {
+ }
+ *x = [8]byte{}
+}
+func testZero8() {
+ a := T8{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero8_ssa(&a.mid)
+ want := T8{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero8 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T9 struct {
+ pre [8]byte
+ mid [9]byte
+ post [8]byte
+}
+
+func zero9_ssa(x *[9]byte) {
+ switch {
+ }
+ *x = [9]byte{}
+}
+func testZero9() {
+ a := T9{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [9]byte{255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero9_ssa(&a.mid)
+ want := T9{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [9]byte{0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero9 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T10 struct {
+ pre [8]byte
+ mid [10]byte
+ post [8]byte
+}
+
+func zero10_ssa(x *[10]byte) {
+ switch {
+ }
+ *x = [10]byte{}
+}
+func testZero10() {
+ a := T10{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [10]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero10_ssa(&a.mid)
+ want := T10{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [10]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero10 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T15 struct {
+ pre [8]byte
+ mid [15]byte
+ post [8]byte
+}
+
+func zero15_ssa(x *[15]byte) {
+ switch {
+ }
+ *x = [15]byte{}
+}
+func testZero15() {
+ a := T15{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [15]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero15_ssa(&a.mid)
+ want := T15{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [15]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero15 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T16 struct {
+ pre [8]byte
+ mid [16]byte
+ post [8]byte
+}
+
+func zero16_ssa(x *[16]byte) {
+ switch {
+ }
+ *x = [16]byte{}
+}
+func testZero16() {
+ a := T16{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [16]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero16_ssa(&a.mid)
+ want := T16{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero16 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T17 struct {
+ pre [8]byte
+ mid [17]byte
+ post [8]byte
+}
+
+func zero17_ssa(x *[17]byte) {
+ switch {
+ }
+ *x = [17]byte{}
+}
+func testZero17() {
+ a := T17{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [17]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero17_ssa(&a.mid)
+ want := T17{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [17]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero17 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T23 struct {
+ pre [8]byte
+ mid [23]byte
+ post [8]byte
+}
+
+func zero23_ssa(x *[23]byte) {
+ switch {
+ }
+ *x = [23]byte{}
+}
+func testZero23() {
+ a := T23{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [23]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero23_ssa(&a.mid)
+ want := T23{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [23]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero23 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T24 struct {
+ pre [8]byte
+ mid [24]byte
+ post [8]byte
+}
+
+func zero24_ssa(x *[24]byte) {
+ switch {
+ }
+ *x = [24]byte{}
+}
+func testZero24() {
+ a := T24{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [24]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero24_ssa(&a.mid)
+ want := T24{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [24]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero24 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T25 struct {
+ pre [8]byte
+ mid [25]byte
+ post [8]byte
+}
+
+func zero25_ssa(x *[25]byte) {
+ switch {
+ }
+ *x = [25]byte{}
+}
+func testZero25() {
+ a := T25{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [25]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero25_ssa(&a.mid)
+ want := T25{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [25]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero25 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T31 struct {
+ pre [8]byte
+ mid [31]byte
+ post [8]byte
+}
+
+func zero31_ssa(x *[31]byte) {
+ switch {
+ }
+ *x = [31]byte{}
+}
+func testZero31() {
+ a := T31{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [31]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero31_ssa(&a.mid)
+ want := T31{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [31]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero31 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T32 struct {
+ pre [8]byte
+ mid [32]byte
+ post [8]byte
+}
+
+func zero32_ssa(x *[32]byte) {
+ switch {
+ }
+ *x = [32]byte{}
+}
+func testZero32() {
+ a := T32{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [32]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero32_ssa(&a.mid)
+ want := T32{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero32 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T33 struct {
+ pre [8]byte
+ mid [33]byte
+ post [8]byte
+}
+
+func zero33_ssa(x *[33]byte) {
+ switch {
+ }
+ *x = [33]byte{}
+}
+func testZero33() {
+ a := T33{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [33]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero33_ssa(&a.mid)
+ want := T33{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [33]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero33 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T63 struct {
+ pre [8]byte
+ mid [63]byte
+ post [8]byte
+}
+
+func zero63_ssa(x *[63]byte) {
+ switch {
+ }
+ *x = [63]byte{}
+}
+func testZero63() {
+ a := T63{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [63]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero63_ssa(&a.mid)
+ want := T63{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [63]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero63 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T64 struct {
+ pre [8]byte
+ mid [64]byte
+ post [8]byte
+}
+
+func zero64_ssa(x *[64]byte) {
+ switch {
+ }
+ *x = [64]byte{}
+}
+func testZero64() {
+ a := T64{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [64]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero64_ssa(&a.mid)
+ want := T64{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [64]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero64 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T65 struct {
+ pre [8]byte
+ mid [65]byte
+ post [8]byte
+}
+
+func zero65_ssa(x *[65]byte) {
+ switch {
+ }
+ *x = [65]byte{}
+}
+func testZero65() {
+ a := T65{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [65]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero65_ssa(&a.mid)
+ want := T65{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [65]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero65 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1023 struct {
+ pre [8]byte
+ mid [1023]byte
+ post [8]byte
+}
+
+func zero1023_ssa(x *[1023]byte) {
+ switch {
+ }
+ *x = [1023]byte{}
+}
+func testZero1023() {
+ a := T1023{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1023]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero1023_ssa(&a.mid)
+ want := T1023{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1023]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero1023 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1024 struct {
+ pre [8]byte
+ mid [1024]byte
+ post [8]byte
+}
+
+func zero1024_ssa(x *[1024]byte) {
+ switch {
+ }
+ *x = [1024]byte{}
+}
+func testZero1024() {
+ a := T1024{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1024]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero1024_ssa(&a.mid)
+ want := T1024{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1024]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero1024 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+type T1025 struct {
+ pre [8]byte
+ mid [1025]byte
+ post [8]byte
+}
+
+func zero1025_ssa(x *[1025]byte) {
+ switch {
+ }
+ *x = [1025]byte{}
+}
+func testZero1025() {
+ a := T1025{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1025]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ zero1025_ssa(&a.mid)
+ want := T1025{[8]byte{255, 255, 255, 255, 255, 255, 255, 255}, [1025]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
+ if a != want {
+ fmt.Printf("zero1025 got=%v, want %v\n", a, want)
+ failed = true
+ }
+}
+
+var failed bool
+
+func main() {
+ testZero1()
+ testZero2()
+ testZero3()
+ testZero4()
+ testZero5()
+ testZero6()
+ testZero7()
+ testZero8()
+ testZero9()
+ testZero10()
+ testZero15()
+ testZero16()
+ testZero17()
+ testZero23()
+ testZero24()
+ testZero25()
+ testZero31()
+ testZero32()
+ testZero33()
+ testZero63()
+ testZero64()
+ testZero65()
+ testZero1023()
+ testZero1024()
+ testZero1025()
+ if failed {
+ panic("failed")
+ }
+}
diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go
new file mode 100644
index 0000000..f09094c
--- /dev/null
+++ b/src/cmd/compile/internal/gc/type.go
@@ -0,0 +1,388 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file provides methods that let us export a Type as an ../ssa:Type.
+// We don't export this package's Type directly because it would lead
+// to an import cycle with this package and ../ssa.
+// TODO: move Type to its own package, then we don't need to dance around import cycles.
+
+package gc
+
+import (
+ "cmd/compile/internal/ssa"
+ "fmt"
+)
+
+func (t *Type) Size() int64 {
+ dowidth(t)
+ return t.Width
+}
+
+func (t *Type) Alignment() int64 {
+ dowidth(t)
+ return int64(t.Align)
+}
+
+func (t *Type) SimpleString() string {
+ return Econv(t.Etype)
+}
+
+func (t *Type) Equal(u ssa.Type) bool {
+ x, ok := u.(*Type)
+ if !ok {
+ return false
+ }
+ return Eqtype(t, x)
+}
+
+// Compare compares types for purposes of the SSA back
+// end, returning an ssa.Cmp (one of CMPlt, CMPeq, CMPgt).
+// The answers are correct for an optimizer
+// or code generator, but not for Go source.
+// For example, "type gcDrainFlags int" results in
+// two Go-different types that Compare equal.
+// The order chosen is also arbitrary, only division into
+// equivalence classes (Types that compare CMPeq) matters.
+func (t *Type) Compare(u ssa.Type) ssa.Cmp {
+ x, ok := u.(*Type)
+ // ssa.CompilerType is smaller than gc.Type
+ // bare pointer equality is easy.
+ if !ok {
+ return ssa.CMPgt
+ }
+ if x == t {
+ return ssa.CMPeq
+ }
+ return t.cmp(x)
+}
+
+func cmpForNe(x bool) ssa.Cmp {
+ if x {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+}
+
+func (r *Sym) cmpsym(s *Sym) ssa.Cmp {
+ if r == s {
+ return ssa.CMPeq
+ }
+ if r == nil {
+ return ssa.CMPlt
+ }
+ if s == nil {
+ return ssa.CMPgt
+ }
+ // Fast sort, not pretty sort
+ if len(r.Name) != len(s.Name) {
+ return cmpForNe(len(r.Name) < len(s.Name))
+ }
+ if r.Pkg != s.Pkg {
+ if len(r.Pkg.Prefix) != len(s.Pkg.Prefix) {
+ return cmpForNe(len(r.Pkg.Prefix) < len(s.Pkg.Prefix))
+ }
+ if r.Pkg.Prefix != s.Pkg.Prefix {
+ return cmpForNe(r.Pkg.Prefix < s.Pkg.Prefix)
+ }
+ }
+ if r.Name != s.Name {
+ return cmpForNe(r.Name < s.Name)
+ }
+ return ssa.CMPeq
+}
+
+// cmp compares two *Types t and x, returning ssa.CMPlt,
+// ssa.CMPeq, ssa.CMPgt as t<x, t==x, t>x, for an arbitrary
+// and optimizer-centric notion of comparison.
+func (t *Type) cmp(x *Type) ssa.Cmp {
+ // This follows the structure of Eqtype in subr.go
+ // with two exceptions.
+ // 1. Symbols are compared more carefully because a <,=,> result is desired.
+ // 2. Maps are treated specially to avoid endless recursion -- maps
+ // contain an internal data type not expressible in Go source code.
+ if t == x {
+ return ssa.CMPeq
+ }
+ if t == nil {
+ return ssa.CMPlt
+ }
+ if x == nil {
+ return ssa.CMPgt
+ }
+
+ if t.Etype != x.Etype {
+ return cmpForNe(t.Etype < x.Etype)
+ }
+
+ if t.Sym != nil || x.Sym != nil {
+ // Special case: we keep byte and uint8 separate
+ // for error messages. Treat them as equal.
+ switch t.Etype {
+ case TUINT8:
+ if (t == Types[TUINT8] || t == bytetype) && (x == Types[TUINT8] || x == bytetype) {
+ return ssa.CMPeq
+ }
+
+ case TINT32:
+ if (t == Types[runetype.Etype] || t == runetype) && (x == Types[runetype.Etype] || x == runetype) {
+ return ssa.CMPeq
+ }
+ }
+ }
+
+ csym := t.Sym.cmpsym(x.Sym)
+ if csym != ssa.CMPeq {
+ return csym
+ }
+
+ if x.Sym != nil {
+ // Syms non-nil, if vargens match then equal.
+ if t.Vargen == x.Vargen {
+ return ssa.CMPeq
+ }
+ if t.Vargen < x.Vargen {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+ }
+ // both syms nil, look at structure below.
+
+ switch t.Etype {
+ case TBOOL, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TUNSAFEPTR, TUINTPTR,
+ TINT8, TINT16, TINT32, TINT64, TINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINT:
+ return ssa.CMPeq
+ }
+
+ switch t.Etype {
+ case TMAP, TFIELD:
+ // No special cases for these two, they are handled
+ // by the general code after the switch.
+
+ case TPTR32, TPTR64:
+ return t.Type.cmp(x.Type)
+
+ case TSTRUCT:
+ if t.Map == nil {
+ if x.Map != nil {
+ return ssa.CMPlt // nil < non-nil
+ }
+ // to the fallthrough
+ } else if x.Map == nil {
+ return ssa.CMPgt // nil > non-nil
+ } else if t.Map.Bucket == t {
+ // Both have non-nil Map
+ // Special case for Maps which include a recursive type where the recursion is not broken with a named type
+ if x.Map.Bucket != x {
+ return ssa.CMPlt // bucket maps are least
+ }
+ return t.Map.cmp(x.Map)
+ } // If t != t.Map.Bucket, fall through to general case
+
+ fallthrough
+ case TINTER:
+ t1 := t.Type
+ x1 := x.Type
+ for ; t1 != nil && x1 != nil; t1, x1 = t1.Down, x1.Down {
+ if t1.Embedded != x1.Embedded {
+ if t1.Embedded < x1.Embedded {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+ }
+ if t1.Note != x1.Note {
+ if t1.Note == nil {
+ return ssa.CMPlt
+ }
+ if x1.Note == nil {
+ return ssa.CMPgt
+ }
+ if *t1.Note != *x1.Note {
+ if *t1.Note < *x1.Note {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+ }
+ }
+ c := t1.Sym.cmpsym(x1.Sym)
+ if c != ssa.CMPeq {
+ return c
+ }
+ c = t1.Type.cmp(x1.Type)
+ if c != ssa.CMPeq {
+ return c
+ }
+ }
+ if t1 == x1 {
+ return ssa.CMPeq
+ }
+ if t1 == nil {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+
+ case TFUNC:
+ t1 := t.Type
+ t2 := x.Type
+ for ; t1 != nil && t2 != nil; t1, t2 = t1.Down, t2.Down {
+ // Loop over fields in structs, ignoring argument names.
+ ta := t1.Type
+ tb := t2.Type
+ for ; ta != nil && tb != nil; ta, tb = ta.Down, tb.Down {
+ if ta.Isddd != tb.Isddd {
+ if ta.Isddd {
+ return ssa.CMPgt
+ }
+ return ssa.CMPlt
+ }
+ c := ta.Type.cmp(tb.Type)
+ if c != ssa.CMPeq {
+ return c
+ }
+ }
+
+ if ta != tb {
+ if t1 == nil {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+ }
+ }
+ if t1 != t2 {
+ if t1 == nil {
+ return ssa.CMPlt
+ }
+ return ssa.CMPgt
+ }
+ return ssa.CMPeq
+
+ case TARRAY:
+ if t.Bound != x.Bound {
+ return cmpForNe(t.Bound < x.Bound)
+ }
+
+ case TCHAN:
+ if t.Chan != x.Chan {
+ return cmpForNe(t.Chan < x.Chan)
+ }
+
+ default:
+ e := fmt.Sprintf("Do not know how to compare %s with %s", t, x)
+ panic(e)
+ }
+
+ c := t.Down.cmp(x.Down)
+ if c != ssa.CMPeq {
+ return c
+ }
+ return t.Type.cmp(x.Type)
+}
+
+func (t *Type) IsBoolean() bool {
+ return t.Etype == TBOOL
+}
+
+func (t *Type) IsInteger() bool {
+ switch t.Etype {
+ case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR:
+ return true
+ }
+ return false
+}
+
+func (t *Type) IsSigned() bool {
+ switch t.Etype {
+ case TINT8, TINT16, TINT32, TINT64, TINT:
+ return true
+ }
+ return false
+}
+
+func (t *Type) IsFloat() bool {
+ return t.Etype == TFLOAT32 || t.Etype == TFLOAT64
+}
+
+func (t *Type) IsComplex() bool {
+ return t.Etype == TCOMPLEX64 || t.Etype == TCOMPLEX128
+}
+
+func (t *Type) IsPtr() bool {
+ return t.Etype == TPTR32 || t.Etype == TPTR64 || t.Etype == TUNSAFEPTR ||
+ t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC
+}
+
+func (t *Type) IsString() bool {
+ return t.Etype == TSTRING
+}
+
+func (t *Type) IsMap() bool {
+ return t.Etype == TMAP
+}
+
+func (t *Type) IsChan() bool {
+ return t.Etype == TCHAN
+}
+
+func (t *Type) IsSlice() bool {
+ return t.Etype == TARRAY && t.Bound < 0
+}
+
+func (t *Type) IsArray() bool {
+ return t.Etype == TARRAY && t.Bound >= 0
+}
+
+func (t *Type) IsStruct() bool {
+ return t.Etype == TSTRUCT
+}
+
+func (t *Type) IsInterface() bool {
+ return t.Etype == TINTER
+}
+
+func (t *Type) Elem() ssa.Type {
+ return t.Type
+}
+func (t *Type) PtrTo() ssa.Type {
+ return Ptrto(t)
+}
+
+func (t *Type) NumFields() int64 {
+ return int64(countfield(t))
+}
+func (t *Type) FieldType(i int64) ssa.Type {
+ // TODO: store fields in a slice so we can
+ // look them up by index in constant time.
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Etype != TFIELD {
+ panic("non-TFIELD in a TSTRUCT")
+ }
+ if i == 0 {
+ return t1.Type
+ }
+ i--
+ }
+ panic("not enough fields")
+}
+func (t *Type) FieldOff(i int64) int64 {
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Etype != TFIELD {
+ panic("non-TFIELD in a TSTRUCT")
+ }
+ if i == 0 {
+ return t1.Width
+ }
+ i--
+ }
+ panic("not enough fields")
+}
+
+func (t *Type) NumElem() int64 {
+ if t.Etype != TARRAY {
+ panic("NumElem on non-TARRAY")
+ }
+ return int64(t.Bound)
+}
+
+func (t *Type) IsMemory() bool { return false }
+func (t *Type) IsFlags() bool { return false }
+func (t *Type) IsVoid() bool { return false }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index d0f942d..7d4c697 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -2566,7 +2566,7 @@
// Defer might stop a panic and show the
// return values as they exist at the time of panic.
// Make sure to zero them on entry to the function.
- nn = append(nn, Nod(OAS, nodarg(t, 1), nil))
+ nn = append(nn, Nod(OAS, nodarg(t, -1), nil))
}
if v == nil || v.Class&PHEAP == 0 {
diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO
new file mode 100644
index 0000000..a457e67
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/TODO
@@ -0,0 +1,68 @@
+This is a list of things that need to be worked on. It will hopefully
+be complete soon.
+
+Coverage
+--------
+
+Correctness
+-----------
+- Debugging info (check & fix as much as we can)
+
+Optimizations (better compiled code)
+------------------------------------
+- Reduce register pressure in scheduler
+- More strength reduction: multiply -> shift/add combos (Worth doing?)
+- Add a value range propagation pass (for bounds elim & bitwidth reduction)
+- Make dead store pass inter-block
+- redundant CMP in sequences like this:
+ SUBQ $8, AX
+ CMP AX, $0
+ JEQ ...
+- If there are a lot of MOVQ $0, ..., then load
+ 0 into a register and use the register as the source instead.
+- Allow arrays of length 1 (or longer, with all constant indexes?) to be SSAable.
+- Figure out how to make PARAMOUT variables ssa-able.
+ They need to get spilled automatically at end-of-function somehow.
+- If strings are being passed around without being interpreted (ptr
+ and len fields being accessed) pass them in xmm registers?
+ Same for interfaces?
+- OpArrayIndex should take its index in AuxInt, not a full value.
+- remove FLAGS from REP instruction clobbers
+- (x86) Combine loads into other ops
+ Note that this is challenging for ops that generate flags
+ because flagalloc wants to move those instructions around for
+ flag regeneration.
+- Non-constant rotate detection.
+- Do 0 <= x && x < n with one unsigned compare
+- nil-check removal in indexed load/store case:
+ lea (%rdx,%rax,1),%rcx
+ test %al,(%rcx) // nil check
+ mov (%rdx,%rax,1),%cl // load to same address
+- any pointer generated by unsafe arithmetic must be non-nil?
+ (Of course that may not be true in general, but it is for all uses
+ in the runtime, and we can play games with unsafe.)
+
+Optimizations (better compiler)
+-------------------------------
+- Smaller Value.Type (int32 or ptr)? Get rid of types altogether?
+- OpStore uses 3 args. Increase the size of Value.argstorage to 3?
+- Use a constant cache for OpConstNil, OpConstInterface, OpConstSlice, maybe OpConstString
+- Handle signed division overflow and sign extension earlier
+- Implement 64 bit const division with high multiply, maybe in the frontend?
+- Add bit widths to complex ops
+
+Regalloc
+--------
+- Make less arch-dependent
+- Allow return values to be ssa-able
+- Handle 2-address instructions
+- Make liveness analysis non-quadratic
+
+Future/other
+------------
+- Start another architecture (arm?)
+- 64-bit ops on 32-bit machines
+- Investigate type equality. During SSA generation, should we use n.Type or (say) TypeBool?
+- Should we get rid of named types in favor of underlying types during SSA generation?
+- Should we introduce a new type equality routine that is less strict than the frontend's?
+- Infrastructure for enabling/disabling/configuring passes
diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go
new file mode 100644
index 0000000..7641811
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/block.go
@@ -0,0 +1,118 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "fmt"
+
+// Block represents a basic block in the control flow graph of a function.
+type Block struct {
+ // A unique identifier for the block. The system will attempt to allocate
+ // these IDs densely, but no guarantees.
+ ID ID
+
+ // The kind of block this is.
+ Kind BlockKind
+
+ // Subsequent blocks, if any. The number and order depend on the block kind.
+ // All successors must be distinct (to make phi values in successors unambiguous).
+ Succs []*Block
+
+ // Inverse of successors.
+ // The order is significant to Phi nodes in the block.
+ Preds []*Block
+ // TODO: predecessors is a pain to maintain. Can we somehow order phi
+ // arguments by block id and have this field computed explicitly when needed?
+
+ // A value that determines how the block is exited. Its value depends on the kind
+ // of the block. For instance, a BlockIf has a boolean control value and BlockExit
+ // has a memory control value.
+ Control *Value
+
+ // Auxiliary info for the block. Its value depends on the Kind.
+ Aux interface{}
+
+ // The unordered set of Values that define the operation of this block.
+ // The list must include the control value, if any. (TODO: need this last condition?)
+ // After the scheduling pass, this list is ordered.
+ Values []*Value
+
+ // The containing function
+ Func *Func
+
+ // Line number for block's control operation
+ Line int32
+
+ // Likely direction for branches.
+ // If BranchLikely, Succs[0] is the most likely branch taken.
+ // If BranchUnlikely, Succs[1] is the most likely branch taken.
+ // Ignored if len(Succs) < 2.
+ // Fatal if not BranchUnknown and len(Succs) > 2.
+ Likely BranchPrediction
+
+ // After flagalloc, records whether flags are live at the end of the block.
+ FlagsLiveAtEnd bool
+
+ // Storage for Succs, Preds, and Values
+ succstorage [2]*Block
+ predstorage [4]*Block
+ valstorage [8]*Value
+}
+
+// kind control successors
+// ------------------------------------------
+// Exit return mem []
+// Plain nil [next]
+// If a boolean Value [then, else]
+// Call mem [nopanic, panic] (control opcode should be OpCall or OpStaticCall)
+type BlockKind int32
+
+// short form print
+func (b *Block) String() string {
+ return fmt.Sprintf("b%d", b.ID)
+}
+
+// long form print
+func (b *Block) LongString() string {
+ s := b.Kind.String()
+ if b.Aux != nil {
+ s += fmt.Sprintf(" %s", b.Aux)
+ }
+ if b.Control != nil {
+ s += fmt.Sprintf(" %s", b.Control)
+ }
+ if len(b.Succs) > 0 {
+ s += " ->"
+ for _, c := range b.Succs {
+ s += " " + c.String()
+ }
+ }
+ switch b.Likely {
+ case BranchUnlikely:
+ s += " (unlikely)"
+ case BranchLikely:
+ s += " (likely)"
+ }
+ return s
+}
+
+// AddEdgeTo adds an edge from block b to block c. Used during building of the
+// SSA graph; do not use on an already-completed SSA graph.
+func (b *Block) AddEdgeTo(c *Block) {
+ b.Succs = append(b.Succs, c)
+ c.Preds = append(c.Preds, b)
+}
+
+func (b *Block) Logf(msg string, args ...interface{}) { b.Func.Logf(msg, args...) }
+func (b *Block) Log() bool { return b.Func.Log() }
+func (b *Block) Fatalf(msg string, args ...interface{}) { b.Func.Fatalf(msg, args...) }
+func (b *Block) Unimplementedf(msg string, args ...interface{}) { b.Func.Unimplementedf(msg, args...) }
+
+type BranchPrediction int8
+
+const (
+ BranchUnlikely = BranchPrediction(-1)
+ BranchUnknown = BranchPrediction(0)
+ BranchLikely = BranchPrediction(+1)
+)
diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go
new file mode 100644
index 0000000..54f7740
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/check.go
@@ -0,0 +1,291 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// checkFunc checks invariants of f.
+func checkFunc(f *Func) {
+ blockMark := make([]bool, f.NumBlocks())
+ valueMark := make([]bool, f.NumValues())
+
+ for _, b := range f.Blocks {
+ if blockMark[b.ID] {
+ f.Fatalf("block %s appears twice in %s!", b, f.Name)
+ }
+ blockMark[b.ID] = true
+ if b.Func != f {
+ f.Fatalf("%s.Func=%s, want %s", b, b.Func.Name, f.Name)
+ }
+
+ if f.RegAlloc == nil {
+ for i, c := range b.Succs {
+ for j, d := range b.Succs {
+ if i != j && c == d {
+ f.Fatalf("%s.Succs has duplicate block %s", b, c)
+ }
+ }
+ }
+ }
+ // Note: duplicate successors are hard in the following case:
+ // if(...) goto x else goto x
+ // x: v = phi(a, b)
+ // If the conditional is true, does v get the value of a or b?
+ // We could solve this other ways, but the easiest is just to
+ // require (by possibly adding empty control-flow blocks) that
+ // all successors are distinct. They will need to be distinct
+ // anyway for register allocation (duplicate successors implies
+ // the existence of critical edges).
+ // After regalloc we can allow non-distinct predecessors.
+
+ for _, p := range b.Preds {
+ var found bool
+ for _, c := range p.Succs {
+ if c == b {
+ found = true
+ break
+ }
+ }
+ if !found {
+ f.Fatalf("block %s is not a succ of its pred block %s", b, p)
+ }
+ }
+
+ switch b.Kind {
+ case BlockExit:
+ if len(b.Succs) != 0 {
+ f.Fatalf("exit block %s has successors", b)
+ }
+ if b.Control == nil {
+ f.Fatalf("exit block %s has no control value", b)
+ }
+ if !b.Control.Type.IsMemory() {
+ f.Fatalf("exit block %s has non-memory control value %s", b, b.Control.LongString())
+ }
+ case BlockRet:
+ if len(b.Succs) != 0 {
+ f.Fatalf("ret block %s has successors", b)
+ }
+ if b.Control == nil {
+ f.Fatalf("ret block %s has nil control %s", b)
+ }
+ if !b.Control.Type.IsMemory() {
+ f.Fatalf("ret block %s has non-memory control value %s", b, b.Control.LongString())
+ }
+ case BlockRetJmp:
+ if len(b.Succs) != 0 {
+ f.Fatalf("retjmp block %s len(Succs)==%d, want 0", b, len(b.Succs))
+ }
+ if b.Control == nil {
+ f.Fatalf("retjmp block %s has nil control %s", b)
+ }
+ if !b.Control.Type.IsMemory() {
+ f.Fatalf("retjmp block %s has non-memory control value %s", b, b.Control.LongString())
+ }
+ if b.Aux == nil {
+ f.Fatalf("retjmp block %s has nil Aux field", b)
+ }
+ case BlockDead:
+ if len(b.Succs) != 0 {
+ f.Fatalf("dead block %s has successors", b)
+ }
+ if len(b.Preds) != 0 {
+ f.Fatalf("dead block %s has predecessors", b)
+ }
+ if len(b.Values) != 0 {
+ f.Fatalf("dead block %s has values", b)
+ }
+ if b.Control != nil {
+ f.Fatalf("dead block %s has a control value", b)
+ }
+ case BlockPlain:
+ if len(b.Succs) != 1 {
+ f.Fatalf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs))
+ }
+ if b.Control != nil {
+ f.Fatalf("plain block %s has non-nil control %s", b, b.Control.LongString())
+ }
+ case BlockIf:
+ if len(b.Succs) != 2 {
+ f.Fatalf("if block %s len(Succs)==%d, want 2", b, len(b.Succs))
+ }
+ if b.Control == nil {
+ f.Fatalf("if block %s has no control value", b)
+ }
+ if !b.Control.Type.IsBoolean() {
+ f.Fatalf("if block %s has non-bool control value %s", b, b.Control.LongString())
+ }
+ case BlockCall:
+ if len(b.Succs) != 1 {
+ f.Fatalf("call block %s len(Succs)==%d, want 1", b, len(b.Succs))
+ }
+ if b.Control == nil {
+ f.Fatalf("call block %s has no control value", b)
+ }
+ if !b.Control.Type.IsMemory() {
+ f.Fatalf("call block %s has non-memory control value %s", b, b.Control.LongString())
+ }
+ case BlockCheck:
+ if len(b.Succs) != 1 {
+ f.Fatalf("check block %s len(Succs)==%d, want 1", b, len(b.Succs))
+ }
+ if b.Control == nil {
+ f.Fatalf("check block %s has no control value", b)
+ }
+ if !b.Control.Type.IsVoid() {
+ f.Fatalf("check block %s has non-void control value %s", b, b.Control.LongString())
+ }
+ case BlockFirst:
+ if len(b.Succs) != 2 {
+ f.Fatalf("plain/dead block %s len(Succs)==%d, want 2", b, len(b.Succs))
+ }
+ if b.Control != nil {
+ f.Fatalf("plain/dead block %s has a control value", b)
+ }
+ }
+ if len(b.Succs) > 2 && b.Likely != BranchUnknown {
+ f.Fatalf("likeliness prediction %d for block %s with %d successors: %s", b.Likely, b, len(b.Succs))
+ }
+
+ for _, v := range b.Values {
+ // Check to make sure argument count makes sense (argLen of -1 indicates
+ // variable length args)
+ nArgs := opcodeTable[v.Op].argLen
+ if nArgs != -1 && int32(len(v.Args)) != nArgs {
+ f.Fatalf("value %v has %d args, expected %d", v.LongString(),
+ len(v.Args), nArgs)
+ }
+
+ // Check to make sure aux values make sense.
+ canHaveAux := false
+ canHaveAuxInt := false
+ switch opcodeTable[v.Op].auxType {
+ case auxNone:
+ case auxBool, auxInt8, auxInt16, auxInt32, auxInt64, auxFloat:
+ canHaveAuxInt = true
+ case auxString, auxSym:
+ canHaveAux = true
+ case auxSymOff, auxSymValAndOff:
+ canHaveAuxInt = true
+ canHaveAux = true
+ default:
+ f.Fatalf("unknown aux type for %s", v.Op)
+ }
+ if !canHaveAux && v.Aux != nil {
+ f.Fatalf("value %v has an Aux value %v but shouldn't", v.LongString(), v.Aux)
+ }
+ if !canHaveAuxInt && v.AuxInt != 0 {
+ f.Fatalf("value %v has an AuxInt value %d but shouldn't", v.LongString(), v.AuxInt)
+ }
+
+ for _, arg := range v.Args {
+ if arg == nil {
+ f.Fatalf("value %v has nil arg", v.LongString())
+ }
+ }
+
+ if valueMark[v.ID] {
+ f.Fatalf("value %s appears twice!", v.LongString())
+ }
+ valueMark[v.ID] = true
+
+ if v.Block != b {
+ f.Fatalf("%s.block != %s", v, b)
+ }
+ if v.Op == OpPhi && len(v.Args) != len(b.Preds) {
+ f.Fatalf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b)
+ }
+
+ if v.Op == OpAddr {
+ if len(v.Args) == 0 {
+ f.Fatalf("no args for OpAddr %s", v.LongString())
+ }
+ if v.Args[0].Op != OpSP && v.Args[0].Op != OpSB {
+ f.Fatalf("bad arg to OpAddr %v", v)
+ }
+ }
+
+ // TODO: check for cycles in values
+ // TODO: check type
+ }
+ }
+
+ // Check to make sure all Blocks referenced are in the function.
+ if !blockMark[f.Entry.ID] {
+ f.Fatalf("entry block %v is missing", f.Entry)
+ }
+ for _, b := range f.Blocks {
+ for _, c := range b.Preds {
+ if !blockMark[c.ID] {
+ f.Fatalf("predecessor block %v for %v is missing", c, b)
+ }
+ }
+ for _, c := range b.Succs {
+ if !blockMark[c.ID] {
+ f.Fatalf("successor block %v for %v is missing", c, b)
+ }
+ }
+ }
+
+ if len(f.Entry.Preds) > 0 {
+ f.Fatalf("entry block %s of %s has predecessor(s) %v", f.Entry, f.Name, f.Entry.Preds)
+ }
+
+ // Check to make sure all Values referenced are in the function.
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for i, a := range v.Args {
+ if !valueMark[a.ID] {
+ f.Fatalf("%v, arg %d of %v, is missing", a, i, v)
+ }
+ }
+ }
+ if b.Control != nil && !valueMark[b.Control.ID] {
+ f.Fatalf("control value for %s is missing: %v", b, b.Control)
+ }
+ }
+ for b := f.freeBlocks; b != nil; b = b.succstorage[0] {
+ if blockMark[b.ID] {
+ f.Fatalf("used block b%d in free list", b.ID)
+ }
+ }
+ for v := f.freeValues; v != nil; v = v.argstorage[0] {
+ if valueMark[v.ID] {
+ f.Fatalf("used value v%d in free list", v.ID)
+ }
+ }
+
+ // Check to make sure all args dominate uses.
+ if f.RegAlloc == nil {
+ // Note: regalloc introduces non-dominating args.
+ // See TODO in regalloc.go.
+ idom := dominators(f)
+ sdom := newSparseTree(f, idom)
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for i, arg := range v.Args {
+ x := arg.Block
+ y := b
+ if v.Op == OpPhi {
+ y = b.Preds[i]
+ }
+ if !domCheck(f, sdom, x, y) {
+ f.Fatalf("arg %d of value %s does not dominate, arg=%s", i, v.LongString(), arg.LongString())
+ }
+ }
+ }
+ if b.Control != nil && !domCheck(f, sdom, b.Control.Block, b) {
+ f.Fatalf("control value %s for %s doesn't dominate", b.Control, b)
+ }
+ }
+ }
+}
+
+// domCheck reports whether x dominates y (including x==y).
+func domCheck(f *Func, sdom sparseTree, x, y *Block) bool {
+ if !sdom.isAncestorEq(y, f.Entry) {
+ // unreachable - ignore
+ return true
+ }
+ return sdom.isAncestorEq(x, y)
+}
diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
new file mode 100644
index 0000000..f68819c
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -0,0 +1,261 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+ "log"
+ "runtime"
+ "strings"
+ "time"
+)
+
+// Compile is the main entry point for this package.
+// Compile modifies f so that on return:
+// · all Values in f map to 0 or 1 assembly instructions of the target architecture
+// · the order of f.Blocks is the order to emit the Blocks
+// · the order of b.Values is the order to emit the Values in each Block
+// · f has a non-nil regAlloc field
+func Compile(f *Func) {
+ // TODO: debugging - set flags to control verbosity of compiler,
+ // which phases to dump IR before/after, etc.
+ if f.Log() {
+ f.Logf("compiling %s\n", f.Name)
+ }
+
+ // hook to print function & phase if panic happens
+ phaseName := "init"
+ defer func() {
+ if phaseName != "" {
+ err := recover()
+ stack := make([]byte, 16384)
+ n := runtime.Stack(stack, false)
+ stack = stack[:n]
+ f.Fatalf("panic during %s while compiling %s:\n\n%v\n\n%s\n", phaseName, f.Name, err, stack)
+ }
+ }()
+
+ // Run all the passes
+ printFunc(f)
+ f.Config.HTML.WriteFunc("start", f)
+ checkFunc(f)
+ const logMemStats = false
+ for _, p := range passes {
+ if !f.Config.optimize && !p.required {
+ continue
+ }
+ f.pass = &p
+ phaseName = p.name
+ if f.Log() {
+ f.Logf(" pass %s begin\n", p.name)
+ }
+ // TODO: capture logging during this pass, add it to the HTML
+ var mStart runtime.MemStats
+ if logMemStats || p.mem {
+ runtime.ReadMemStats(&mStart)
+ }
+
+ tStart := time.Now()
+ p.fn(f)
+ tEnd := time.Now()
+
+ // Need something less crude than "Log the whole intermediate result".
+ if f.Log() || f.Config.HTML != nil {
+ time := tEnd.Sub(tStart).Nanoseconds()
+ var stats string
+ if logMemStats {
+ var mEnd runtime.MemStats
+ runtime.ReadMemStats(&mEnd)
+ nBytes := mEnd.TotalAlloc - mStart.TotalAlloc
+ nAllocs := mEnd.Mallocs - mStart.Mallocs
+ stats = fmt.Sprintf("[%d ns %d allocs %d bytes]", time, nAllocs, nBytes)
+ } else {
+ stats = fmt.Sprintf("[%d ns]", time)
+ }
+
+ f.Logf(" pass %s end %s\n", p.name, stats)
+ printFunc(f)
+ f.Config.HTML.WriteFunc(fmt.Sprintf("after %s <span class=\"stats\">%s</span>", phaseName, stats), f)
+ }
+ if p.time || p.mem {
+ // Surround timing information w/ enough context to allow comparisons.
+ time := tEnd.Sub(tStart).Nanoseconds()
+ if p.time {
+ f.logStat("TIME(ns)", time)
+ }
+ if p.mem {
+ var mEnd runtime.MemStats
+ runtime.ReadMemStats(&mEnd)
+ nBytes := mEnd.TotalAlloc - mStart.TotalAlloc
+ nAllocs := mEnd.Mallocs - mStart.Mallocs
+ f.logStat("TIME(ns):BYTES:ALLOCS", time, nBytes, nAllocs)
+ }
+ }
+ checkFunc(f)
+ }
+
+ // Squash error printing defer
+ phaseName = ""
+}
+
+type pass struct {
+ name string
+ fn func(*Func)
+ required bool
+ disabled bool
+ time bool // report time to run pass
+ mem bool // report mem stats to run pass
+ stats int // pass reports own "stats" (e.g., branches removed)
+ debug int // pass performs some debugging. =1 should be in error-testing-friendly Warnl format.
+ test int // pass-specific ad-hoc option, perhaps useful in development
+}
+
+// PhaseOption sets the specified flag in the specified ssa phase,
+// returning empty string if this was successful or a string explaining
+// the error if it was not. A version of the phase name with "_"
+// replaced by " " is also checked for a match.
+// See gc/lex.go for dissection of the option string. Example use:
+// GO_GCFLAGS=-d=ssa/generic_cse/time,ssa/generic_cse/stats,ssa/generic_cse/debug=3 ./make.bash ...
+//
+func PhaseOption(phase, flag string, val int) string {
+ underphase := strings.Replace(phase, "_", " ", -1)
+ for i, p := range passes {
+ if p.name == phase || p.name == underphase {
+ switch flag {
+ case "on":
+ p.disabled = val == 0
+ case "off":
+ p.disabled = val != 0
+ case "time":
+ p.time = val != 0
+ case "mem":
+ p.mem = val != 0
+ case "debug":
+ p.debug = val
+ case "stats":
+ p.stats = val
+ case "test":
+ p.test = val
+ default:
+ return fmt.Sprintf("Did not find a flag matching %s in -d=ssa/%s debug option", flag, phase)
+ }
+ if p.disabled && p.required {
+ return fmt.Sprintf("Cannot disable required SSA phase %s using -d=ssa/%s debug option", phase, phase)
+ }
+ passes[i] = p
+ return ""
+ }
+ }
+ return fmt.Sprintf("Did not find a phase matching %s in -d=ssa/... debug option", phase)
+}
+
+// list of passes for the compiler
+var passes = [...]pass{
+ // TODO: combine phielim and copyelim into a single pass?
+ {name: "early phielim", fn: phielim},
+ {name: "early copyelim", fn: copyelim},
+ {name: "early deadcode", fn: deadcode}, // remove generated dead code to avoid doing pointless work during opt
+ {name: "short circuit", fn: shortcircuit},
+ {name: "decompose user", fn: decomposeUser, required: true},
+ {name: "decompose builtin", fn: decomposeBuiltIn, required: true},
+ {name: "opt", fn: opt, required: true}, // TODO: split required rules and optimizing rules
+ {name: "zero arg cse", fn: zcse, required: true}, // required to merge OpSB values
+ {name: "opt deadcode", fn: deadcode}, // remove any blocks orphaned during opt
+ {name: "generic cse", fn: cse},
+ {name: "phiopt", fn: phiopt},
+ {name: "nilcheckelim", fn: nilcheckelim},
+ {name: "prove", fn: prove},
+ {name: "generic deadcode", fn: deadcode},
+ {name: "fuse", fn: fuse},
+ {name: "dse", fn: dse},
+ {name: "tighten", fn: tighten}, // move values closer to their uses
+ {name: "lower", fn: lower, required: true},
+ {name: "lowered cse", fn: cse},
+ {name: "lowered deadcode", fn: deadcode, required: true},
+ {name: "checkLower", fn: checkLower, required: true},
+ {name: "late phielim", fn: phielim},
+ {name: "late copyelim", fn: copyelim},
+ {name: "late deadcode", fn: deadcode},
+ {name: "critical", fn: critical, required: true}, // remove critical edges
+ {name: "likelyadjust", fn: likelyadjust},
+ {name: "layout", fn: layout, required: true}, // schedule blocks
+ {name: "schedule", fn: schedule, required: true}, // schedule values
+ {name: "flagalloc", fn: flagalloc, required: true}, // allocate flags register
+ {name: "regalloc", fn: regalloc, required: true}, // allocate int & float registers + stack slots
+ {name: "trim", fn: trim}, // remove empty blocks
+}
+
+// Double-check phase ordering constraints.
+// This code is intended to document the ordering requirements
+// between different phases. It does not override the passes
+// list above.
+type constraint struct {
+ a, b string // a must come before b
+}
+
+var passOrder = [...]constraint{
+ // prove reliese on common-subexpression elimination for maximum benefits.
+ {"generic cse", "prove"},
+ // deadcode after prove to eliminate all new dead blocks.
+ {"prove", "generic deadcode"},
+ // common-subexpression before dead-store elim, so that we recognize
+ // when two address expressions are the same.
+ {"generic cse", "dse"},
+ // cse substantially improves nilcheckelim efficacy
+ {"generic cse", "nilcheckelim"},
+ // allow deadcode to clean up after nilcheckelim
+ {"nilcheckelim", "generic deadcode"},
+ // nilcheckelim generates sequences of plain basic blocks
+ {"nilcheckelim", "fuse"},
+ // nilcheckelim relies on opt to rewrite user nil checks
+ {"opt", "nilcheckelim"},
+ // tighten should happen before lowering to avoid splitting naturally paired instructions such as CMP/SET
+ {"tighten", "lower"},
+ // tighten will be most effective when as many values have been removed as possible
+ {"generic deadcode", "tighten"},
+ {"generic cse", "tighten"},
+ // don't run optimization pass until we've decomposed builtin objects
+ {"decompose builtin", "opt"},
+ // don't layout blocks until critical edges have been removed
+ {"critical", "layout"},
+ // regalloc requires the removal of all critical edges
+ {"critical", "regalloc"},
+ // regalloc requires all the values in a block to be scheduled
+ {"schedule", "regalloc"},
+ // checkLower must run after lowering & subsequent dead code elim
+ {"lower", "checkLower"},
+ {"lowered deadcode", "checkLower"},
+ // flagalloc needs instructions to be scheduled.
+ {"schedule", "flagalloc"},
+ // regalloc needs flags to be allocated first.
+ {"flagalloc", "regalloc"},
+ // trim needs regalloc to be done first.
+ {"regalloc", "trim"},
+}
+
+func init() {
+ for _, c := range passOrder {
+ a, b := c.a, c.b
+ i := -1
+ j := -1
+ for k, p := range passes {
+ if p.name == a {
+ i = k
+ }
+ if p.name == b {
+ j = k
+ }
+ }
+ if i < 0 {
+ log.Panicf("pass %s not found", a)
+ }
+ if j < 0 {
+ log.Panicf("pass %s not found", b)
+ }
+ if i >= j {
+ log.Panicf("passes %s and %s out of order", a, b)
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
new file mode 100644
index 0000000..8657509
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -0,0 +1,235 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "cmd/internal/obj"
+ "crypto/sha1"
+ "fmt"
+ "os"
+ "strings"
+)
+
+type Config struct {
+ arch string // "amd64", etc.
+ IntSize int64 // 4 or 8
+ PtrSize int64 // 4 or 8
+ lowerBlock func(*Block) bool // lowering function
+ lowerValue func(*Value, *Config) bool // lowering function
+ fe Frontend // callbacks into compiler frontend
+ HTML *HTMLWriter // html writer, for debugging
+ ctxt *obj.Link // Generic arch information
+ optimize bool // Do optimization
+ curFunc *Func
+
+ // TODO: more stuff. Compiler flags of interest, ...
+
+ // Given an environment variable used for debug hash match,
+ // what file (if any) receives the yes/no logging?
+ logfiles map[string]*os.File
+
+ // Storage for low-numbered values and blocks.
+ values [2000]Value
+ blocks [200]Block
+
+ domblockstore []ID // scratch space for computing dominators
+ scrSparse []*sparseSet // scratch sparse sets to be re-used.
+}
+
+type TypeSource interface {
+ TypeBool() Type
+ TypeInt8() Type
+ TypeInt16() Type
+ TypeInt32() Type
+ TypeInt64() Type
+ TypeUInt8() Type
+ TypeUInt16() Type
+ TypeUInt32() Type
+ TypeUInt64() Type
+ TypeInt() Type
+ TypeFloat32() Type
+ TypeFloat64() Type
+ TypeUintptr() Type
+ TypeString() Type
+ TypeBytePtr() Type // TODO: use unsafe.Pointer instead?
+
+ CanSSA(t Type) bool
+}
+
+type Logger interface {
+ // Logf logs a message from the compiler.
+ Logf(string, ...interface{})
+
+ // Log returns true if logging is not a no-op
+ // some logging calls account for more than a few heap allocations.
+ Log() bool
+
+ // Fatal reports a compiler error and exits.
+ Fatalf(line int32, msg string, args ...interface{})
+
+ // Unimplemented reports that the function cannot be compiled.
+ // It will be removed once SSA work is complete.
+ Unimplementedf(line int32, msg string, args ...interface{})
+
+ // Warnl writes compiler messages in the form expected by "errorcheck" tests
+ Warnl(line int, fmt_ string, args ...interface{})
+
+ // Fowards the Debug_checknil flag from gc
+ Debug_checknil() bool
+}
+
+type Frontend interface {
+ TypeSource
+ Logger
+
+ // StringData returns a symbol pointing to the given string's contents.
+ StringData(string) interface{} // returns *gc.Sym
+
+ // Auto returns a Node for an auto variable of the given type.
+ // The SSA compiler uses this function to allocate space for spills.
+ Auto(Type) GCNode
+
+ // Line returns a string describing the given line number.
+ Line(int32) string
+}
+
+// interface used to hold *gc.Node. We'd use *gc.Node directly but
+// that would lead to an import cycle.
+type GCNode interface {
+ Typ() Type
+ String() string
+}
+
+// NewConfig returns a new configuration object for the given architecture.
+func NewConfig(arch string, fe Frontend, ctxt *obj.Link, optimize bool) *Config {
+ c := &Config{arch: arch, fe: fe}
+ switch arch {
+ case "amd64":
+ c.IntSize = 8
+ c.PtrSize = 8
+ c.lowerBlock = rewriteBlockAMD64
+ c.lowerValue = rewriteValueAMD64
+ case "386":
+ c.IntSize = 4
+ c.PtrSize = 4
+ c.lowerBlock = rewriteBlockAMD64
+ c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support
+ default:
+ fe.Unimplementedf(0, "arch %s not implemented", arch)
+ }
+ c.ctxt = ctxt
+ c.optimize = optimize
+
+ // Assign IDs to preallocated values/blocks.
+ for i := range c.values {
+ c.values[i].ID = ID(i)
+ }
+ for i := range c.blocks {
+ c.blocks[i].ID = ID(i)
+ }
+
+ c.logfiles = make(map[string]*os.File)
+
+ return c
+}
+
+func (c *Config) Frontend() Frontend { return c.fe }
+
+// NewFunc returns a new, empty function object.
+// Caller must call f.Free() before calling NewFunc again.
+func (c *Config) NewFunc() *Func {
+ // TODO(khr): should this function take name, type, etc. as arguments?
+ if c.curFunc != nil {
+ c.Fatalf(0, "NewFunc called without previous Free")
+ }
+ f := &Func{Config: c, NamedValues: map[LocalSlot][]*Value{}}
+ c.curFunc = f
+ return f
+}
+
+func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) }
+func (c *Config) Log() bool { return c.fe.Log() }
+func (c *Config) Fatalf(line int32, msg string, args ...interface{}) { c.fe.Fatalf(line, msg, args...) }
+func (c *Config) Unimplementedf(line int32, msg string, args ...interface{}) {
+ c.fe.Unimplementedf(line, msg, args...)
+}
+func (c *Config) Warnl(line int, msg string, args ...interface{}) { c.fe.Warnl(line, msg, args...) }
+func (c *Config) Debug_checknil() bool { return c.fe.Debug_checknil() }
+
+func (c *Config) logDebugHashMatch(evname, name string) {
+ var file *os.File
+ file = c.logfiles[evname]
+ if file == nil {
+ file = os.Stdout
+ tmpfile := os.Getenv("GSHS_LOGFILE")
+ if tmpfile != "" {
+ var ok error
+ file, ok = os.Create(tmpfile)
+ if ok != nil {
+ c.Fatalf(0, "Could not open hash-testing logfile %s", tmpfile)
+ }
+ }
+ c.logfiles[evname] = file
+ }
+ s := fmt.Sprintf("%s triggered %s\n", evname, name)
+ file.WriteString(s)
+ file.Sync()
+}
+
+// DebugHashMatch returns true if environment variable evname
+// 1) is empty (this is a special more-quickly implemented case of 3)
+// 2) is "y" or "Y"
+// 3) is a suffix of the sha1 hash of name
+// 4) is a suffix of the environment variable
+// fmt.Sprintf("%s%d", evname, n)
+// provided that all such variables are nonempty for 0 <= i <= n
+// Otherwise it returns false.
+// When true is returned the message
+// "%s triggered %s\n", evname, name
+// is printed on the file named in environment variable
+// GSHS_LOGFILE
+// or standard out if that is empty or there is an error
+// opening the file.
+
+func (c *Config) DebugHashMatch(evname, name string) bool {
+ evhash := os.Getenv(evname)
+ if evhash == "" {
+ return true // default behavior with no EV is "on"
+ }
+ if evhash == "y" || evhash == "Y" {
+ c.logDebugHashMatch(evname, name)
+ return true
+ }
+ if evhash == "n" || evhash == "N" {
+ return false
+ }
+ // Check the hash of the name against a partial input hash.
+ // We use this feature to do a binary search to
+ // find a function that is incorrectly compiled.
+ hstr := ""
+ for _, b := range sha1.Sum([]byte(name)) {
+ hstr += fmt.Sprintf("%08b", b)
+ }
+
+ if strings.HasSuffix(hstr, evhash) {
+ c.logDebugHashMatch(evname, name)
+ return true
+ }
+
+ // Iteratively try additional hashes to allow tests for multi-point
+ // failure.
+ for i := 0; true; i++ {
+ ev := fmt.Sprintf("%s%d", evname, i)
+ evv := os.Getenv(ev)
+ if evv == "" {
+ break
+ }
+ if strings.HasSuffix(hstr, evv) {
+ c.logDebugHashMatch(ev, name)
+ return true
+ }
+ }
+ return false
+}
diff --git a/src/cmd/compile/internal/ssa/copyelim.go b/src/cmd/compile/internal/ssa/copyelim.go
new file mode 100644
index 0000000..cfeff21
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/copyelim.go
@@ -0,0 +1,60 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// copyelim removes all copies from f.
+func copyelim(f *Func) {
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ copyelimValue(v)
+ }
+ v := b.Control
+ if v != nil {
+ for v.Op == OpCopy {
+ v = v.Args[0]
+ }
+ b.Control = v
+ }
+ }
+
+ // Update named values.
+ for _, name := range f.Names {
+ values := f.NamedValues[name]
+ for i, v := range values {
+ x := v
+ for x.Op == OpCopy {
+ x = x.Args[0]
+ }
+ if x != v {
+ values[i] = v
+ }
+ }
+ }
+}
+
+func copyelimValue(v *Value) {
+ // elide any copies generated during rewriting
+ for i, a := range v.Args {
+ if a.Op != OpCopy {
+ continue
+ }
+ // Rewriting can generate OpCopy loops.
+ // They are harmless (see removePredecessor),
+ // but take care to stop if we find a cycle.
+ slow := a // advances every other iteration
+ var advance bool
+ for a.Op == OpCopy {
+ a = a.Args[0]
+ if slow == a {
+ break
+ }
+ if advance {
+ slow = slow.Args[0]
+ }
+ advance = !advance
+ }
+ v.Args[i] = a
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/critical.go b/src/cmd/compile/internal/ssa/critical.go
new file mode 100644
index 0000000..9fea0ec
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/critical.go
@@ -0,0 +1,39 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// critical splits critical edges (those that go from a block with
+// more than one outedge to a block with more than one inedge).
+// Regalloc wants a critical-edge-free CFG so it can implement phi values.
+func critical(f *Func) {
+ for _, b := range f.Blocks {
+ if len(b.Preds) <= 1 {
+ continue
+ }
+
+ // split input edges coming from multi-output blocks.
+ for i, c := range b.Preds {
+ if c.Kind == BlockPlain {
+ continue // only single output block
+ }
+
+ // allocate a new block to place on the edge
+ d := f.NewBlock(BlockPlain)
+ d.Line = c.Line
+
+ // splice it in
+ d.Preds = append(d.Preds, c)
+ d.Succs = append(d.Succs, b)
+ b.Preds[i] = d
+ // replace b with d in c's successor list.
+ for j, b2 := range c.Succs {
+ if b2 == b {
+ c.Succs[j] = d
+ break
+ }
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go
new file mode 100644
index 0000000..c447485
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/cse.go
@@ -0,0 +1,304 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+ "sort"
+)
+
+const (
+ cmpDepth = 4
+)
+
+// cse does common-subexpression elimination on the Function.
+// Values are just relinked, nothing is deleted. A subsequent deadcode
+// pass is required to actually remove duplicate expressions.
+func cse(f *Func) {
+ // Two values are equivalent if they satisfy the following definition:
+ // equivalent(v, w):
+ // v.op == w.op
+ // v.type == w.type
+ // v.aux == w.aux
+ // v.auxint == w.auxint
+ // len(v.args) == len(w.args)
+ // v.block == w.block if v.op == OpPhi
+ // equivalent(v.args[i], w.args[i]) for i in 0..len(v.args)-1
+
+ // The algorithm searches for a partition of f's values into
+ // equivalence classes using the above definition.
+ // It starts with a coarse partition and iteratively refines it
+ // until it reaches a fixed point.
+
+ // Make initial coarse partitions by using a subset of the conditions above.
+ a := make([]*Value, 0, f.NumValues())
+ auxIDs := auxmap{}
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if auxIDs[v.Aux] == 0 {
+ auxIDs[v.Aux] = int32(len(auxIDs)) + 1
+ }
+ if v.Type.IsMemory() {
+ continue // memory values can never cse
+ }
+ if opcodeTable[v.Op].commutative && len(v.Args) == 2 && v.Args[1].ID < v.Args[0].ID {
+ // Order the arguments of binary commutative operations.
+ v.Args[0], v.Args[1] = v.Args[1], v.Args[0]
+ }
+ a = append(a, v)
+ }
+ }
+ partition := partitionValues(a, auxIDs)
+
+ // map from value id back to eqclass id
+ valueEqClass := make([]ID, f.NumValues())
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ // Use negative equivalence class #s for unique values.
+ valueEqClass[v.ID] = -v.ID
+ }
+ }
+ for i, e := range partition {
+ if f.pass.debug > 1 && len(e) > 500 {
+ fmt.Printf("CSE.large partition (%d): ", len(e))
+ for j := 0; j < 3; j++ {
+ fmt.Printf("%s ", e[j].LongString())
+ }
+ fmt.Println()
+ }
+
+ for _, v := range e {
+ valueEqClass[v.ID] = ID(i)
+ }
+ if f.pass.debug > 2 && len(e) > 1 {
+ fmt.Printf("CSE.partition #%d:", i)
+ for _, v := range e {
+ fmt.Printf(" %s", v.String())
+ }
+ fmt.Printf("\n")
+ }
+ }
+
+ // Find an equivalence class where some members of the class have
+ // non-equivalent arguments. Split the equivalence class appropriately.
+ // Repeat until we can't find any more splits.
+ for {
+ changed := false
+
+ // partition can grow in the loop. By not using a range loop here,
+ // we process new additions as they arrive, avoiding O(n^2) behavior.
+ for i := 0; i < len(partition); i++ {
+ e := partition[i]
+ v := e[0]
+ // all values in this equiv class that are not equivalent to v get moved
+ // into another equiv class.
+ // To avoid allocating while building that equivalence class,
+ // move the values equivalent to v to the beginning of e
+ // and other values to the end of e.
+ allvals := e
+ eqloop:
+ for j := 1; j < len(e); {
+ w := e[j]
+ equivalent := true
+ for i := 0; i < len(v.Args); i++ {
+ if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] {
+ equivalent = false
+ break
+ }
+ }
+ if !equivalent || !v.Type.Equal(w.Type) {
+ // w is not equivalent to v.
+ // move it to the end and shrink e.
+ e[j], e[len(e)-1] = e[len(e)-1], e[j]
+ e = e[:len(e)-1]
+ valueEqClass[w.ID] = ID(len(partition))
+ changed = true
+ continue eqloop
+ }
+ // v and w are equivalent. Keep w in e.
+ j++
+ }
+ partition[i] = e
+ if len(e) < len(allvals) {
+ partition = append(partition, allvals[len(e):])
+ }
+ }
+
+ if !changed {
+ break
+ }
+ }
+
+ // Compute dominator tree
+ idom := dominators(f)
+ sdom := newSparseTree(f, idom)
+
+ // Compute substitutions we would like to do. We substitute v for w
+ // if v and w are in the same equivalence class and v dominates w.
+ rewrite := make([]*Value, f.NumValues())
+ for _, e := range partition {
+ for len(e) > 1 {
+ // Find a maximal dominant element in e
+ v := e[0]
+ for _, w := range e[1:] {
+ if sdom.isAncestorEq(w.Block, v.Block) {
+ v = w
+ }
+ }
+
+ // Replace all elements of e which v dominates
+ for i := 0; i < len(e); {
+ w := e[i]
+ if w == v {
+ e, e[i] = e[:len(e)-1], e[len(e)-1]
+ } else if sdom.isAncestorEq(v.Block, w.Block) {
+ rewrite[w.ID] = v
+ e, e[i] = e[:len(e)-1], e[len(e)-1]
+ } else {
+ i++
+ }
+ }
+ }
+ }
+
+ rewrites := int64(0)
+
+ // Apply substitutions
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for i, w := range v.Args {
+ if x := rewrite[w.ID]; x != nil {
+ v.SetArg(i, x)
+ rewrites++
+ }
+ }
+ }
+ if v := b.Control; v != nil {
+ if x := rewrite[v.ID]; x != nil {
+ if v.Op == OpNilCheck {
+ // nilcheck pass will remove the nil checks and log
+ // them appropriately, so don't mess with them here.
+ continue
+ }
+ b.Control = x
+ }
+ }
+ }
+ if f.pass.stats > 0 {
+ f.logStat("CSE REWRITES", rewrites)
+ }
+}
+
+// An eqclass approximates an equivalence class. During the
+// algorithm it may represent the union of several of the
+// final equivalence classes.
+type eqclass []*Value
+
+// partitionValues partitions the values into equivalence classes
+// based on having all the following features match:
+// - opcode
+// - type
+// - auxint
+// - aux
+// - nargs
+// - block # if a phi op
+// - first two arg's opcodes and auxint
+// - NOT first two arg's aux; that can break CSE.
+// partitionValues returns a list of equivalence classes, each
+// being a sorted by ID list of *Values. The eqclass slices are
+// backed by the same storage as the input slice.
+// Equivalence classes of size 1 are ignored.
+func partitionValues(a []*Value, auxIDs auxmap) []eqclass {
+ sort.Sort(sortvalues{a, auxIDs})
+
+ var partition []eqclass
+ for len(a) > 0 {
+ v := a[0]
+ j := 1
+ for ; j < len(a); j++ {
+ w := a[j]
+ if cmpVal(v, w, auxIDs, cmpDepth) != CMPeq {
+ break
+ }
+ }
+ if j > 1 {
+ partition = append(partition, a[:j])
+ }
+ a = a[j:]
+ }
+
+ return partition
+}
+func lt2Cmp(isLt bool) Cmp {
+ if isLt {
+ return CMPlt
+ }
+ return CMPgt
+}
+
+type auxmap map[interface{}]int32
+
+func cmpVal(v, w *Value, auxIDs auxmap, depth int) Cmp {
+ // Try to order these comparison by cost (cheaper first)
+ if v.Op != w.Op {
+ return lt2Cmp(v.Op < w.Op)
+ }
+ if v.AuxInt != w.AuxInt {
+ return lt2Cmp(v.AuxInt < w.AuxInt)
+ }
+ if len(v.Args) != len(w.Args) {
+ return lt2Cmp(len(v.Args) < len(w.Args))
+ }
+ if v.Op == OpPhi && v.Block != w.Block {
+ return lt2Cmp(v.Block.ID < w.Block.ID)
+ }
+
+ if tc := v.Type.Compare(w.Type); tc != CMPeq {
+ return tc
+ }
+
+ if v.Aux != w.Aux {
+ if v.Aux == nil {
+ return CMPlt
+ }
+ if w.Aux == nil {
+ return CMPgt
+ }
+ return lt2Cmp(auxIDs[v.Aux] < auxIDs[w.Aux])
+ }
+
+ if depth > 0 {
+ for i := range v.Args {
+ if v.Args[i] == w.Args[i] {
+ // skip comparing equal args
+ continue
+ }
+ if ac := cmpVal(v.Args[i], w.Args[i], auxIDs, depth-1); ac != CMPeq {
+ return ac
+ }
+ }
+ }
+
+ return CMPeq
+}
+
+// Sort values to make the initial partition.
+type sortvalues struct {
+ a []*Value // array of values
+ auxIDs auxmap // aux -> aux ID map
+}
+
+func (sv sortvalues) Len() int { return len(sv.a) }
+func (sv sortvalues) Swap(i, j int) { sv.a[i], sv.a[j] = sv.a[j], sv.a[i] }
+func (sv sortvalues) Less(i, j int) bool {
+ v := sv.a[i]
+ w := sv.a[j]
+ if cmp := cmpVal(v, w, sv.auxIDs, cmpDepth); cmp != CMPeq {
+ return cmp == CMPlt
+ }
+
+ // Sort by value ID last to keep the sort result deterministic.
+ return v.ID < w.ID
+}
diff --git a/src/cmd/compile/internal/ssa/cse_test.go b/src/cmd/compile/internal/ssa/cse_test.go
new file mode 100644
index 0000000..905939f
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/cse_test.go
@@ -0,0 +1,123 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+type tstAux struct {
+ s string
+}
+
+// This tests for a bug found when partitioning, but not sorting by the Aux value.
+func TestCSEAuxPartitionBug(t *testing.T) {
+ c := testConfig(t)
+ arg1Aux := &tstAux{"arg1-aux"}
+ arg2Aux := &tstAux{"arg2-aux"}
+ arg3Aux := &tstAux{"arg3-aux"}
+
+ // construct lots of values with args that have aux values and place
+ // them in an order that triggers the bug
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("start", OpInitMem, TypeMem, 0, nil),
+ Valu("sp", OpSP, TypeBytePtr, 0, nil),
+ Valu("r7", OpAdd64, TypeInt64, 0, nil, "arg3", "arg1"),
+ Valu("r1", OpAdd64, TypeInt64, 0, nil, "arg1", "arg2"),
+ Valu("arg1", OpArg, TypeInt64, 0, arg1Aux),
+ Valu("arg2", OpArg, TypeInt64, 0, arg2Aux),
+ Valu("arg3", OpArg, TypeInt64, 0, arg3Aux),
+ Valu("r9", OpAdd64, TypeInt64, 0, nil, "r7", "r8"),
+ Valu("r4", OpAdd64, TypeInt64, 0, nil, "r1", "r2"),
+ Valu("r8", OpAdd64, TypeInt64, 0, nil, "arg3", "arg2"),
+ Valu("r2", OpAdd64, TypeInt64, 0, nil, "arg1", "arg2"),
+ Valu("raddr", OpAddr, TypeInt64Ptr, 0, nil, "sp"),
+ Valu("raddrdef", OpVarDef, TypeMem, 0, nil, "start"),
+ Valu("r6", OpAdd64, TypeInt64, 0, nil, "r4", "r5"),
+ Valu("r3", OpAdd64, TypeInt64, 0, nil, "arg1", "arg2"),
+ Valu("r5", OpAdd64, TypeInt64, 0, nil, "r2", "r3"),
+ Valu("r10", OpAdd64, TypeInt64, 0, nil, "r6", "r9"),
+ Valu("rstore", OpStore, TypeMem, 8, nil, "raddr", "r10", "raddrdef"),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("rstore")))
+
+ CheckFunc(fun.f)
+ cse(fun.f)
+ deadcode(fun.f)
+ CheckFunc(fun.f)
+
+ s1Cnt := 2
+ // r1 == r2 == r3, needs to remove two of this set
+ s2Cnt := 1
+ // r4 == r5, needs to remove one of these
+ for k, v := range fun.values {
+ if v.Op == OpInvalid {
+ switch k {
+ case "r1":
+ fallthrough
+ case "r2":
+ fallthrough
+ case "r3":
+ if s1Cnt == 0 {
+ t.Errorf("cse removed all of r1,r2,r3")
+ }
+ s1Cnt--
+
+ case "r4":
+ fallthrough
+ case "r5":
+ if s2Cnt == 0 {
+ t.Errorf("cse removed all of r4,r5")
+ }
+ s2Cnt--
+ default:
+ t.Errorf("cse removed %s, but shouldn't have", k)
+ }
+ }
+ }
+
+ if s1Cnt != 0 || s2Cnt != 0 {
+ t.Errorf("%d values missed during cse", s1Cnt+s2Cnt)
+ }
+}
+
+// TestZCSE tests the zero arg cse.
+func TestZCSE(t *testing.T) {
+ c := testConfig(t)
+
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("start", OpInitMem, TypeMem, 0, nil),
+ Valu("sp", OpSP, TypeBytePtr, 0, nil),
+ Valu("sb1", OpSB, TypeBytePtr, 0, nil),
+ Valu("sb2", OpSB, TypeBytePtr, 0, nil),
+ Valu("addr1", OpAddr, TypeInt64Ptr, 0, nil, "sb1"),
+ Valu("addr2", OpAddr, TypeInt64Ptr, 0, nil, "sb2"),
+ Valu("a1ld", OpLoad, TypeInt64, 0, nil, "addr1", "start"),
+ Valu("a2ld", OpLoad, TypeInt64, 0, nil, "addr2", "start"),
+ Valu("c1", OpConst64, TypeInt64, 1, nil),
+ Valu("r1", OpAdd64, TypeInt64, 0, nil, "a1ld", "c1"),
+ Valu("c2", OpConst64, TypeInt64, 1, nil),
+ Valu("r2", OpAdd64, TypeInt64, 0, nil, "a2ld", "c2"),
+ Valu("r3", OpAdd64, TypeInt64, 0, nil, "r1", "r2"),
+ Valu("raddr", OpAddr, TypeInt64Ptr, 0, nil, "sp"),
+ Valu("raddrdef", OpVarDef, TypeMem, 0, nil, "start"),
+ Valu("rstore", OpStore, TypeMem, 8, nil, "raddr", "r3", "raddrdef"),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("rstore")))
+
+ CheckFunc(fun.f)
+ zcse(fun.f)
+ deadcode(fun.f)
+ CheckFunc(fun.f)
+
+ if fun.values["c1"].Op != OpInvalid && fun.values["c2"].Op != OpInvalid {
+ t.Errorf("zsce should have removed c1 or c2")
+ }
+ if fun.values["sb1"].Op != OpInvalid && fun.values["sb2"].Op != OpInvalid {
+ t.Errorf("zsce should have removed sb1 or sb2")
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go
new file mode 100644
index 0000000..a33de43
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/deadcode.go
@@ -0,0 +1,270 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// findlive returns the reachable blocks and live values in f.
+func findlive(f *Func) (reachable []bool, live []bool) {
+ reachable = reachableBlocks(f)
+ live = liveValues(f, reachable)
+ return
+}
+
+// reachableBlocks returns the reachable blocks in f.
+func reachableBlocks(f *Func) []bool {
+ reachable := make([]bool, f.NumBlocks())
+ reachable[f.Entry.ID] = true
+ p := []*Block{f.Entry} // stack-like worklist
+ for len(p) > 0 {
+ // Pop a reachable block
+ b := p[len(p)-1]
+ p = p[:len(p)-1]
+ // Mark successors as reachable
+ s := b.Succs
+ if b.Kind == BlockFirst {
+ s = s[:1]
+ }
+ for _, c := range s {
+ if !reachable[c.ID] {
+ reachable[c.ID] = true
+ p = append(p, c) // push
+ }
+ }
+ }
+ return reachable
+}
+
+// liveValues returns the live values in f.
+// reachable is a map from block ID to whether the block is reachable.
+func liveValues(f *Func, reachable []bool) []bool {
+ live := make([]bool, f.NumValues())
+
+ // After regalloc, consider all values to be live.
+ // See the comment at the top of regalloc.go and in deadcode for details.
+ if f.RegAlloc != nil {
+ for i := range live {
+ live[i] = true
+ }
+ return live
+ }
+
+ // Find all live values
+ var q []*Value // stack-like worklist of unscanned values
+
+ // Starting set: all control values of reachable blocks are live.
+ for _, b := range f.Blocks {
+ if !reachable[b.ID] {
+ continue
+ }
+ if v := b.Control; v != nil && !live[v.ID] {
+ live[v.ID] = true
+ q = append(q, v)
+ }
+ }
+
+ // Compute transitive closure of live values.
+ for len(q) > 0 {
+ // pop a reachable value
+ v := q[len(q)-1]
+ q = q[:len(q)-1]
+ for i, x := range v.Args {
+ if v.Op == OpPhi && !reachable[v.Block.Preds[i].ID] {
+ continue
+ }
+ if !live[x.ID] {
+ live[x.ID] = true
+ q = append(q, x) // push
+ }
+ }
+ }
+
+ return live
+}
+
+// deadcode removes dead code from f.
+func deadcode(f *Func) {
+ // deadcode after regalloc is forbidden for now. Regalloc
+ // doesn't quite generate legal SSA which will lead to some
+ // required moves being eliminated. See the comment at the
+ // top of regalloc.go for details.
+ if f.RegAlloc != nil {
+ f.Fatalf("deadcode after regalloc")
+ }
+
+ // Find reachable blocks.
+ reachable := reachableBlocks(f)
+
+ // Get rid of edges from dead to live code.
+ for _, b := range f.Blocks {
+ if reachable[b.ID] {
+ continue
+ }
+ for _, c := range b.Succs {
+ if reachable[c.ID] {
+ c.removePred(b)
+ }
+ }
+ }
+
+ // Get rid of dead edges from live code.
+ for _, b := range f.Blocks {
+ if !reachable[b.ID] {
+ continue
+ }
+ if b.Kind != BlockFirst {
+ continue
+ }
+ c := b.Succs[1]
+ b.Succs[1] = nil
+ b.Succs = b.Succs[:1]
+ b.Kind = BlockPlain
+ b.Likely = BranchUnknown
+
+ if reachable[c.ID] {
+ // Note: c must be reachable through some other edge.
+ c.removePred(b)
+ }
+ }
+
+ // Splice out any copies introduced during dead block removal.
+ copyelim(f)
+
+ // Find live values.
+ live := liveValues(f, reachable)
+
+ // Remove dead & duplicate entries from namedValues map.
+ s := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(s)
+ i := 0
+ for _, name := range f.Names {
+ j := 0
+ s.clear()
+ values := f.NamedValues[name]
+ for _, v := range values {
+ if live[v.ID] && !s.contains(v.ID) {
+ values[j] = v
+ j++
+ s.add(v.ID)
+ }
+ }
+ if j == 0 {
+ delete(f.NamedValues, name)
+ } else {
+ f.Names[i] = name
+ i++
+ for k := len(values) - 1; k >= j; k-- {
+ values[k] = nil
+ }
+ f.NamedValues[name] = values[:j]
+ }
+ }
+ for k := len(f.Names) - 1; k >= i; k-- {
+ f.Names[k] = LocalSlot{}
+ }
+ f.Names = f.Names[:i]
+
+ // Remove dead values from blocks' value list. Return dead
+ // values to the allocator.
+ for _, b := range f.Blocks {
+ i := 0
+ for _, v := range b.Values {
+ if live[v.ID] {
+ b.Values[i] = v
+ i++
+ } else {
+ f.freeValue(v)
+ }
+ }
+ // aid GC
+ tail := b.Values[i:]
+ for j := range tail {
+ tail[j] = nil
+ }
+ b.Values = b.Values[:i]
+ }
+
+ // Remove unreachable blocks. Return dead blocks to allocator.
+ i = 0
+ for _, b := range f.Blocks {
+ if reachable[b.ID] {
+ f.Blocks[i] = b
+ i++
+ } else {
+ if len(b.Values) > 0 {
+ b.Fatalf("live values in unreachable block %v: %v", b, b.Values)
+ }
+ f.freeBlock(b)
+ }
+ }
+ // zero remainder to help GC
+ tail := f.Blocks[i:]
+ for j := range tail {
+ tail[j] = nil
+ }
+ f.Blocks = f.Blocks[:i]
+}
+
+// removePred removes the predecessor p from b's predecessor list.
+func (b *Block) removePred(p *Block) {
+ var i int
+ found := false
+ for j, q := range b.Preds {
+ if q == p {
+ i = j
+ found = true
+ break
+ }
+ }
+ // TODO: the above loop could make the deadcode pass take quadratic time
+ if !found {
+ b.Fatalf("can't find predecessor %v of %v\n", p, b)
+ }
+
+ n := len(b.Preds) - 1
+ b.Preds[i] = b.Preds[n]
+ b.Preds[n] = nil // aid GC
+ b.Preds = b.Preds[:n]
+
+ // rewrite phi ops to match the new predecessor list
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ continue
+ }
+ v.Args[i] = v.Args[n]
+ v.Args[n] = nil // aid GC
+ v.Args = v.Args[:n]
+ phielimValue(v)
+ // Note: this is trickier than it looks. Replacing
+ // a Phi with a Copy can in general cause problems because
+ // Phi and Copy don't have exactly the same semantics.
+ // Phi arguments always come from a predecessor block,
+ // whereas copies don't. This matters in loops like:
+ // 1: x = (Phi y)
+ // y = (Add x 1)
+ // goto 1
+ // If we replace Phi->Copy, we get
+ // 1: x = (Copy y)
+ // y = (Add x 1)
+ // goto 1
+ // (Phi y) refers to the *previous* value of y, whereas
+ // (Copy y) refers to the *current* value of y.
+ // The modified code has a cycle and the scheduler
+ // will barf on it.
+ //
+ // Fortunately, this situation can only happen for dead
+ // code loops. We know the code we're working with is
+ // not dead, so we're ok.
+ // Proof: If we have a potential bad cycle, we have a
+ // situation like this:
+ // x = (Phi z)
+ // y = (op1 x ...)
+ // z = (op2 y ...)
+ // Where opX are not Phi ops. But such a situation
+ // implies a cycle in the dominator graph. In the
+ // example, x.Block dominates y.Block, y.Block dominates
+ // z.Block, and z.Block dominates x.Block (treating
+ // "dominates" as reflexive). Cycles in the dominator
+ // graph can only happen in an unreachable cycle.
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go
new file mode 100644
index 0000000..24934d5
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/deadcode_test.go
@@ -0,0 +1,134 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func TestDeadLoop(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")),
+ // dead loop
+ Bloc("deadblock",
+ // dead value in dead block
+ Valu("deadval", OpConstBool, TypeBool, 1, nil),
+ If("deadval", "deadblock", "exit")))
+
+ CheckFunc(fun.f)
+ Deadcode(fun.f)
+ CheckFunc(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["deadblock"] {
+ t.Errorf("dead block not removed")
+ }
+ for _, v := range b.Values {
+ if v == fun.values["deadval"] {
+ t.Errorf("control value of dead block not removed")
+ }
+ }
+ }
+}
+
+func TestDeadValue(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("deadval", OpConst64, TypeInt64, 37, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ Deadcode(fun.f)
+ CheckFunc(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ for _, v := range b.Values {
+ if v == fun.values["deadval"] {
+ t.Errorf("dead value not removed")
+ }
+ }
+ }
+}
+
+func TestNeverTaken(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("cond", OpConstBool, TypeBool, 0, nil),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ If("cond", "then", "else")),
+ Bloc("then",
+ Goto("exit")),
+ Bloc("else",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ Opt(fun.f)
+ Deadcode(fun.f)
+ CheckFunc(fun.f)
+
+ if fun.blocks["entry"].Kind != BlockPlain {
+ t.Errorf("if(false) not simplified")
+ }
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["then"] {
+ t.Errorf("then block still present")
+ }
+ for _, v := range b.Values {
+ if v == fun.values["cond"] {
+ t.Errorf("constant condition still present")
+ }
+ }
+ }
+
+}
+
+func TestNestedDeadBlocks(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("cond", OpConstBool, TypeBool, 0, nil),
+ If("cond", "b2", "b4")),
+ Bloc("b2",
+ If("cond", "b3", "b4")),
+ Bloc("b3",
+ If("cond", "b3", "b4")),
+ Bloc("b4",
+ If("cond", "b3", "exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ Opt(fun.f)
+ CheckFunc(fun.f)
+ Deadcode(fun.f)
+ CheckFunc(fun.f)
+ if fun.blocks["entry"].Kind != BlockPlain {
+ t.Errorf("if(false) not simplified")
+ }
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["b2"] {
+ t.Errorf("b2 block still present")
+ }
+ if b == fun.blocks["b3"] {
+ t.Errorf("b3 block still present")
+ }
+ for _, v := range b.Values {
+ if v == fun.values["cond"] {
+ t.Errorf("constant condition still present")
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
new file mode 100644
index 0000000..bad0e00
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -0,0 +1,116 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// dse does dead-store elimination on the Function.
+// Dead stores are those which are unconditionally followed by
+// another store to the same location, with no intervening load.
+// This implementation only works within a basic block. TODO: use something more global.
+func dse(f *Func) {
+ var stores []*Value
+ loadUse := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(loadUse)
+ storeUse := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(storeUse)
+ shadowed := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(shadowed)
+ for _, b := range f.Blocks {
+ // Find all the stores in this block. Categorize their uses:
+ // loadUse contains stores which are used by a subsequent load.
+ // storeUse contains stores which are used by a subsequent store.
+ loadUse.clear()
+ storeUse.clear()
+ stores = stores[:0]
+ for _, v := range b.Values {
+ if v.Op == OpPhi {
+ // Ignore phis - they will always be first and can't be eliminated
+ continue
+ }
+ if v.Type.IsMemory() {
+ stores = append(stores, v)
+ for _, a := range v.Args {
+ if a.Block == b && a.Type.IsMemory() {
+ storeUse.add(a.ID)
+ if v.Op != OpStore && v.Op != OpZero && v.Op != OpVarDef && v.Op != OpVarKill {
+ // CALL, DUFFCOPY, etc. are both
+ // reads and writes.
+ loadUse.add(a.ID)
+ }
+ }
+ }
+ } else {
+ for _, a := range v.Args {
+ if a.Block == b && a.Type.IsMemory() {
+ loadUse.add(a.ID)
+ }
+ }
+ }
+ }
+ if len(stores) == 0 {
+ continue
+ }
+
+ // find last store in the block
+ var last *Value
+ for _, v := range stores {
+ if storeUse.contains(v.ID) {
+ continue
+ }
+ if last != nil {
+ b.Fatalf("two final stores - simultaneous live stores %s %s", last, v)
+ }
+ last = v
+ }
+ if last == nil {
+ b.Fatalf("no last store found - cycle?")
+ }
+
+ // Walk backwards looking for dead stores. Keep track of shadowed addresses.
+ // An "address" is an SSA Value which encodes both the address and size of
+ // the write. This code will not remove dead stores to the same address
+ // of different types.
+ shadowed.clear()
+ v := last
+
+ walkloop:
+ if loadUse.contains(v.ID) {
+ // Someone might be reading this memory state.
+ // Clear all shadowed addresses.
+ shadowed.clear()
+ }
+ if v.Op == OpStore || v.Op == OpZero {
+ if shadowed.contains(v.Args[0].ID) {
+ // Modify store into a copy
+ if v.Op == OpStore {
+ // store addr value mem
+ v.SetArgs1(v.Args[2])
+ } else {
+ // zero addr mem
+ sz := v.Args[0].Type.Elem().Size()
+ if v.AuxInt != sz {
+ f.Fatalf("mismatched zero/store sizes: %d and %d [%s]",
+ v.AuxInt, sz, v.LongString())
+ }
+ v.SetArgs1(v.Args[1])
+ }
+ v.Aux = nil
+ v.AuxInt = 0
+ v.Op = OpCopy
+ } else {
+ shadowed.add(v.Args[0].ID)
+ }
+ }
+ // walk to previous store
+ if v.Op == OpPhi {
+ continue // At start of block. Move on to next block.
+ }
+ for _, a := range v.Args {
+ if a.Block == b && a.Type.IsMemory() {
+ v = a
+ goto walkloop
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go
new file mode 100644
index 0000000..9ded8bd
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/deadstore_test.go
@@ -0,0 +1,97 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func TestDeadStore(t *testing.T) {
+ c := testConfig(t)
+ elemType := &TypeImpl{Size_: 8, Name: "testtype"}
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr", Elem_: elemType} // dummy for testing
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("start", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Valu("v", OpConstBool, TypeBool, 1, nil),
+ Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
+ Valu("addr2", OpAddr, ptrType, 0, nil, "sb"),
+ Valu("addr3", OpAddr, ptrType, 0, nil, "sb"),
+ Valu("zero1", OpZero, TypeMem, 8, nil, "addr3", "start"),
+ Valu("store1", OpStore, TypeMem, 1, nil, "addr1", "v", "zero1"),
+ Valu("store2", OpStore, TypeMem, 1, nil, "addr2", "v", "store1"),
+ Valu("store3", OpStore, TypeMem, 1, nil, "addr1", "v", "store2"),
+ Valu("store4", OpStore, TypeMem, 1, nil, "addr3", "v", "store3"),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("store3")))
+
+ CheckFunc(fun.f)
+ dse(fun.f)
+ CheckFunc(fun.f)
+
+ v1 := fun.values["store1"]
+ if v1.Op != OpCopy {
+ t.Errorf("dead store not removed")
+ }
+
+ v2 := fun.values["zero1"]
+ if v2.Op != OpCopy {
+ t.Errorf("dead store (zero) not removed")
+ }
+}
+func TestDeadStorePhi(t *testing.T) {
+ // make sure we don't get into an infinite loop with phi values.
+ c := testConfig(t)
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("start", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Valu("v", OpConstBool, TypeBool, 1, nil),
+ Valu("addr", OpAddr, ptrType, 0, nil, "sb"),
+ Goto("loop")),
+ Bloc("loop",
+ Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"),
+ Valu("store", OpStore, TypeMem, 1, nil, "addr", "v", "phi"),
+ If("v", "loop", "exit")),
+ Bloc("exit",
+ Exit("store")))
+
+ CheckFunc(fun.f)
+ dse(fun.f)
+ CheckFunc(fun.f)
+}
+
+func TestDeadStoreTypes(t *testing.T) {
+ // Make sure a narrow store can't shadow a wider one. We test an even
+ // stronger restriction, that one store can't shadow another unless the
+ // types of the address fields are identical (where identicalness is
+ // decided by the CSE pass).
+ c := testConfig(t)
+ t1 := &TypeImpl{Size_: 8, Ptr: true, Name: "t1"}
+ t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"}
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("start", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Valu("v", OpConstBool, TypeBool, 1, nil),
+ Valu("addr1", OpAddr, t1, 0, nil, "sb"),
+ Valu("addr2", OpAddr, t2, 0, nil, "sb"),
+ Valu("store1", OpStore, TypeMem, 1, nil, "addr1", "v", "start"),
+ Valu("store2", OpStore, TypeMem, 1, nil, "addr2", "v", "store1"),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("store2")))
+
+ CheckFunc(fun.f)
+ cse(fun.f)
+ dse(fun.f)
+ CheckFunc(fun.f)
+
+ v := fun.values["store1"]
+ if v.Op == OpCopy {
+ t.Errorf("store %s incorrectly removed", v)
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
new file mode 100644
index 0000000..826eff1
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -0,0 +1,261 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// decompose converts phi ops on compound builtin types into phi
+// ops on simple types.
+// (The remaining compound ops are decomposed with rewrite rules.)
+func decomposeBuiltIn(f *Func) {
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ continue
+ }
+ decomposeBuiltInPhi(v)
+ }
+ }
+
+ // Split up named values into their components.
+ // NOTE: the component values we are making are dead at this point.
+ // We must do the opt pass before any deadcode elimination or we will
+ // lose the name->value correspondence.
+ for _, name := range f.Names {
+ t := name.Type
+ switch {
+ case t.IsComplex():
+ var elemType Type
+ if t.Size() == 16 {
+ elemType = f.Config.fe.TypeFloat64()
+ } else {
+ elemType = f.Config.fe.TypeFloat32()
+ }
+ rName := LocalSlot{name.N, elemType, name.Off}
+ iName := LocalSlot{name.N, elemType, name.Off + elemType.Size()}
+ f.Names = append(f.Names, rName, iName)
+ for _, v := range f.NamedValues[name] {
+ r := v.Block.NewValue1(v.Line, OpComplexReal, elemType, v)
+ i := v.Block.NewValue1(v.Line, OpComplexImag, elemType, v)
+ f.NamedValues[rName] = append(f.NamedValues[rName], r)
+ f.NamedValues[iName] = append(f.NamedValues[iName], i)
+ }
+ case t.IsString():
+ ptrType := f.Config.fe.TypeBytePtr()
+ lenType := f.Config.fe.TypeInt()
+ ptrName := LocalSlot{name.N, ptrType, name.Off}
+ lenName := LocalSlot{name.N, lenType, name.Off + f.Config.PtrSize}
+ f.Names = append(f.Names, ptrName, lenName)
+ for _, v := range f.NamedValues[name] {
+ ptr := v.Block.NewValue1(v.Line, OpStringPtr, ptrType, v)
+ len := v.Block.NewValue1(v.Line, OpStringLen, lenType, v)
+ f.NamedValues[ptrName] = append(f.NamedValues[ptrName], ptr)
+ f.NamedValues[lenName] = append(f.NamedValues[lenName], len)
+ }
+ case t.IsSlice():
+ ptrType := f.Config.fe.TypeBytePtr()
+ lenType := f.Config.fe.TypeInt()
+ ptrName := LocalSlot{name.N, ptrType, name.Off}
+ lenName := LocalSlot{name.N, lenType, name.Off + f.Config.PtrSize}
+ capName := LocalSlot{name.N, lenType, name.Off + 2*f.Config.PtrSize}
+ f.Names = append(f.Names, ptrName, lenName, capName)
+ for _, v := range f.NamedValues[name] {
+ ptr := v.Block.NewValue1(v.Line, OpSlicePtr, ptrType, v)
+ len := v.Block.NewValue1(v.Line, OpSliceLen, lenType, v)
+ cap := v.Block.NewValue1(v.Line, OpSliceCap, lenType, v)
+ f.NamedValues[ptrName] = append(f.NamedValues[ptrName], ptr)
+ f.NamedValues[lenName] = append(f.NamedValues[lenName], len)
+ f.NamedValues[capName] = append(f.NamedValues[capName], cap)
+ }
+ case t.IsInterface():
+ ptrType := f.Config.fe.TypeBytePtr()
+ typeName := LocalSlot{name.N, ptrType, name.Off}
+ dataName := LocalSlot{name.N, ptrType, name.Off + f.Config.PtrSize}
+ f.Names = append(f.Names, typeName, dataName)
+ for _, v := range f.NamedValues[name] {
+ typ := v.Block.NewValue1(v.Line, OpITab, ptrType, v)
+ data := v.Block.NewValue1(v.Line, OpIData, ptrType, v)
+ f.NamedValues[typeName] = append(f.NamedValues[typeName], typ)
+ f.NamedValues[dataName] = append(f.NamedValues[dataName], data)
+ }
+ case t.Size() > f.Config.IntSize:
+ f.Unimplementedf("undecomposed named type %s", t)
+ }
+ }
+}
+
+func decomposeBuiltInPhi(v *Value) {
+ // TODO: decompose 64-bit ops on 32-bit archs?
+ switch {
+ case v.Type.IsComplex():
+ decomposeComplexPhi(v)
+ case v.Type.IsString():
+ decomposeStringPhi(v)
+ case v.Type.IsSlice():
+ decomposeSlicePhi(v)
+ case v.Type.IsInterface():
+ decomposeInterfacePhi(v)
+ case v.Type.Size() > v.Block.Func.Config.IntSize:
+ v.Unimplementedf("undecomposed type %s", v.Type)
+ }
+}
+
+func decomposeStringPhi(v *Value) {
+ fe := v.Block.Func.Config.fe
+ ptrType := fe.TypeBytePtr()
+ lenType := fe.TypeInt()
+
+ ptr := v.Block.NewValue0(v.Line, OpPhi, ptrType)
+ len := v.Block.NewValue0(v.Line, OpPhi, lenType)
+ for _, a := range v.Args {
+ ptr.AddArg(a.Block.NewValue1(v.Line, OpStringPtr, ptrType, a))
+ len.AddArg(a.Block.NewValue1(v.Line, OpStringLen, lenType, a))
+ }
+ v.reset(OpStringMake)
+ v.AddArg(ptr)
+ v.AddArg(len)
+}
+
+func decomposeSlicePhi(v *Value) {
+ fe := v.Block.Func.Config.fe
+ ptrType := fe.TypeBytePtr()
+ lenType := fe.TypeInt()
+
+ ptr := v.Block.NewValue0(v.Line, OpPhi, ptrType)
+ len := v.Block.NewValue0(v.Line, OpPhi, lenType)
+ cap := v.Block.NewValue0(v.Line, OpPhi, lenType)
+ for _, a := range v.Args {
+ ptr.AddArg(a.Block.NewValue1(v.Line, OpSlicePtr, ptrType, a))
+ len.AddArg(a.Block.NewValue1(v.Line, OpSliceLen, lenType, a))
+ cap.AddArg(a.Block.NewValue1(v.Line, OpSliceCap, lenType, a))
+ }
+ v.reset(OpSliceMake)
+ v.AddArg(ptr)
+ v.AddArg(len)
+ v.AddArg(cap)
+}
+
+func decomposeComplexPhi(v *Value) {
+ fe := v.Block.Func.Config.fe
+ var partType Type
+ switch z := v.Type.Size(); z {
+ case 8:
+ partType = fe.TypeFloat32()
+ case 16:
+ partType = fe.TypeFloat64()
+ default:
+ v.Fatalf("decomposeComplexPhi: bad complex size %d", z)
+ }
+
+ real := v.Block.NewValue0(v.Line, OpPhi, partType)
+ imag := v.Block.NewValue0(v.Line, OpPhi, partType)
+ for _, a := range v.Args {
+ real.AddArg(a.Block.NewValue1(v.Line, OpComplexReal, partType, a))
+ imag.AddArg(a.Block.NewValue1(v.Line, OpComplexImag, partType, a))
+ }
+ v.reset(OpComplexMake)
+ v.AddArg(real)
+ v.AddArg(imag)
+}
+
+func decomposeInterfacePhi(v *Value) {
+ ptrType := v.Block.Func.Config.fe.TypeBytePtr()
+
+ itab := v.Block.NewValue0(v.Line, OpPhi, ptrType)
+ data := v.Block.NewValue0(v.Line, OpPhi, ptrType)
+ for _, a := range v.Args {
+ itab.AddArg(a.Block.NewValue1(v.Line, OpITab, ptrType, a))
+ data.AddArg(a.Block.NewValue1(v.Line, OpIData, ptrType, a))
+ }
+ v.reset(OpIMake)
+ v.AddArg(itab)
+ v.AddArg(data)
+}
+
+func decomposeUser(f *Func) {
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ continue
+ }
+ decomposeUserPhi(v)
+ }
+ }
+ // Split up named values into their components.
+ // NOTE: the component values we are making are dead at this point.
+ // We must do the opt pass before any deadcode elimination or we will
+ // lose the name->value correspondence.
+ i := 0
+ for _, name := range f.Names {
+ t := name.Type
+ switch {
+ case t.IsStruct():
+ n := t.NumFields()
+ for _, v := range f.NamedValues[name] {
+ for i := int64(0); i < n; i++ {
+ fname := LocalSlot{name.N, t.FieldType(i), name.Off + t.FieldOff(i)} // TODO: use actual field name?
+ x := v.Block.NewValue1I(v.Line, OpStructSelect, t.FieldType(i), i, v)
+ f.NamedValues[fname] = append(f.NamedValues[fname], x)
+ }
+ }
+ delete(f.NamedValues, name)
+ default:
+ f.Names[i] = name
+ i++
+ }
+ }
+ f.Names = f.Names[:i]
+}
+
+func decomposeUserPhi(v *Value) {
+ switch {
+ case v.Type.IsStruct():
+ decomposeStructPhi(v)
+ }
+ // TODO: Arrays of length 1?
+}
+
+func decomposeStructPhi(v *Value) {
+ t := v.Type
+ n := t.NumFields()
+ var fields [MaxStruct]*Value
+ for i := int64(0); i < n; i++ {
+ fields[i] = v.Block.NewValue0(v.Line, OpPhi, t.FieldType(i))
+ }
+ for _, a := range v.Args {
+ for i := int64(0); i < n; i++ {
+ fields[i].AddArg(a.Block.NewValue1I(v.Line, OpStructSelect, t.FieldType(i), i, a))
+ }
+ }
+ v.reset(StructMakeOp(n))
+ v.AddArgs(fields[:n]...)
+
+ // Recursively decompose phis for each field.
+ for _, f := range fields[:n] {
+ if f.Type.IsStruct() {
+ decomposeStructPhi(f)
+ }
+ }
+}
+
+// MaxStruct is the maximum number of fields a struct
+// can have and still be SSAable.
+const MaxStruct = 4
+
+// StructMakeOp returns the opcode to construct a struct with the
+// given number of fields.
+func StructMakeOp(nf int64) Op {
+ switch nf {
+ case 0:
+ return OpStructMake0
+ case 1:
+ return OpStructMake1
+ case 2:
+ return OpStructMake2
+ case 3:
+ return OpStructMake3
+ case 4:
+ return OpStructMake4
+ }
+ panic("too many fields in an SSAable struct")
+}
diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go
new file mode 100644
index 0000000..2d53b5a
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/dom.go
@@ -0,0 +1,367 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// mark values
+const (
+ notFound = 0 // block has not been discovered yet
+ notExplored = 1 // discovered and in queue, outedges not processed yet
+ explored = 2 // discovered and in queue, outedges processed
+ done = 3 // all done, in output ordering
+)
+
+// This file contains code to compute the dominator tree
+// of a control-flow graph.
+
+// postorder computes a postorder traversal ordering for the
+// basic blocks in f. Unreachable blocks will not appear.
+func postorder(f *Func) []*Block {
+ mark := make([]byte, f.NumBlocks())
+
+ // result ordering
+ var order []*Block
+
+ // stack of blocks
+ var s []*Block
+ s = append(s, f.Entry)
+ mark[f.Entry.ID] = notExplored
+ for len(s) > 0 {
+ b := s[len(s)-1]
+ switch mark[b.ID] {
+ case explored:
+ // Children have all been visited. Pop & output block.
+ s = s[:len(s)-1]
+ mark[b.ID] = done
+ order = append(order, b)
+ case notExplored:
+ // Children have not been visited yet. Mark as explored
+ // and queue any children we haven't seen yet.
+ mark[b.ID] = explored
+ for _, c := range b.Succs {
+ if mark[c.ID] == notFound {
+ mark[c.ID] = notExplored
+ s = append(s, c)
+ }
+ }
+ default:
+ b.Fatalf("bad stack state %v %d", b, mark[b.ID])
+ }
+ }
+ return order
+}
+
+type linkedBlocks func(*Block) []*Block
+
+const nscratchslices = 8
+
+// experimentally, functions with 512 or fewer blocks account
+// for 75% of memory (size) allocation for dominator computation
+// in make.bash.
+const minscratchblocks = 512
+
+func (cfg *Config) scratchBlocksForDom(maxBlockID int) (a, b, c, d, e, f, g, h []ID) {
+ tot := maxBlockID * nscratchslices
+ scratch := cfg.domblockstore
+ if len(scratch) < tot {
+ // req = min(1.5*tot, nscratchslices*minscratchblocks)
+ // 50% padding allows for graph growth in later phases.
+ req := (tot * 3) >> 1
+ if req < nscratchslices*minscratchblocks {
+ req = nscratchslices * minscratchblocks
+ }
+ scratch = make([]ID, req)
+ cfg.domblockstore = scratch
+ } else {
+ // Clear as much of scratch as we will (re)use
+ scratch = scratch[0:tot]
+ for i := range scratch {
+ scratch[i] = 0
+ }
+ }
+
+ a = scratch[0*maxBlockID : 1*maxBlockID]
+ b = scratch[1*maxBlockID : 2*maxBlockID]
+ c = scratch[2*maxBlockID : 3*maxBlockID]
+ d = scratch[3*maxBlockID : 4*maxBlockID]
+ e = scratch[4*maxBlockID : 5*maxBlockID]
+ f = scratch[5*maxBlockID : 6*maxBlockID]
+ g = scratch[6*maxBlockID : 7*maxBlockID]
+ h = scratch[7*maxBlockID : 8*maxBlockID]
+
+ return
+}
+
+// dfs performs a depth first search over the blocks starting at the set of
+// blocks in the entries list (in arbitrary order). dfnum contains a mapping
+// from block id to an int indicating the order the block was reached or
+// notFound if the block was not reached. order contains a mapping from dfnum
+// to block.
+func (f *Func) dfs(entries []*Block, succFn linkedBlocks, dfnum, order, parent []ID) (fromID []*Block) {
+ maxBlockID := entries[0].Func.NumBlocks()
+
+ fromID = make([]*Block, maxBlockID)
+
+ for _, entry := range entries[0].Func.Blocks {
+ eid := entry.ID
+ if fromID[eid] != nil {
+ panic("Colliding entry IDs")
+ }
+ fromID[eid] = entry
+ }
+
+ n := ID(0)
+ s := make([]*Block, 0, 256)
+ for _, entry := range entries {
+ if dfnum[entry.ID] != notFound {
+ continue // already found from a previous entry
+ }
+ s = append(s, entry)
+ parent[entry.ID] = entry.ID
+ for len(s) > 0 {
+ node := s[len(s)-1]
+ s = s[:len(s)-1]
+
+ n++
+ for _, w := range succFn(node) {
+ // if it has a dfnum, we've already visited it
+ if dfnum[w.ID] == notFound {
+ s = append(s, w)
+ parent[w.ID] = node.ID
+ dfnum[w.ID] = notExplored
+ }
+ }
+ dfnum[node.ID] = n
+ order[n] = node.ID
+ }
+ }
+
+ return
+}
+
+// dominators computes the dominator tree for f. It returns a slice
+// which maps block ID to the immediate dominator of that block.
+// Unreachable blocks map to nil. The entry block maps to nil.
+func dominators(f *Func) []*Block {
+ preds := func(b *Block) []*Block { return b.Preds }
+ succs := func(b *Block) []*Block { return b.Succs }
+
+ //TODO: benchmark and try to find criteria for swapping between
+ // dominatorsSimple and dominatorsLT
+ return f.dominatorsLT([]*Block{f.Entry}, preds, succs)
+}
+
+// postDominators computes the post-dominator tree for f.
+func postDominators(f *Func) []*Block {
+ preds := func(b *Block) []*Block { return b.Preds }
+ succs := func(b *Block) []*Block { return b.Succs }
+
+ if len(f.Blocks) == 0 {
+ return nil
+ }
+
+ // find the exit blocks
+ var exits []*Block
+ for i := len(f.Blocks) - 1; i >= 0; i-- {
+ switch f.Blocks[i].Kind {
+ case BlockExit, BlockRet, BlockRetJmp, BlockCall, BlockCheck:
+ exits = append(exits, f.Blocks[i])
+ break
+ }
+ }
+
+ // infinite loop with no exit
+ if exits == nil {
+ return make([]*Block, f.NumBlocks())
+ }
+ return f.dominatorsLT(exits, succs, preds)
+}
+
+// dominatorsLt runs Lengauer-Tarjan to compute a dominator tree starting at
+// entry and using predFn/succFn to find predecessors/successors to allow
+// computing both dominator and post-dominator trees.
+func (f *Func) dominatorsLT(entries []*Block, predFn linkedBlocks, succFn linkedBlocks) []*Block {
+ // Based on Lengauer-Tarjan from Modern Compiler Implementation in C -
+ // Appel with optimizations from Finding Dominators in Practice -
+ // Georgiadis
+
+ maxBlockID := entries[0].Func.NumBlocks()
+
+ dfnum, vertex, parent, semi, samedom, ancestor, best, bucket := f.Config.scratchBlocksForDom(maxBlockID)
+
+ // dfnum := make([]ID, maxBlockID) // conceptually int32, but punning for allocation purposes.
+ // vertex := make([]ID, maxBlockID)
+ // parent := make([]ID, maxBlockID)
+
+ // semi := make([]ID, maxBlockID)
+ // samedom := make([]ID, maxBlockID)
+ // ancestor := make([]ID, maxBlockID)
+ // best := make([]ID, maxBlockID)
+ // bucket := make([]ID, maxBlockID)
+
+ // Step 1. Carry out a depth first search of the problem graph. Number
+ // the vertices from 1 to n as they are reached during the search.
+ fromID := f.dfs(entries, succFn, dfnum, vertex, parent)
+
+ idom := make([]*Block, maxBlockID)
+
+ // Step 2. Compute the semidominators of all vertices by applying
+ // Theorem 4. Carry out the computation vertex by vertex in decreasing
+ // order by number.
+ for i := maxBlockID - 1; i > 0; i-- {
+ w := vertex[i]
+ if w == 0 {
+ continue
+ }
+
+ if dfnum[w] == notFound {
+ // skip unreachable node
+ continue
+ }
+
+ // Step 3. Implicitly define the immediate dominator of each
+ // vertex by applying Corollary 1. (reordered)
+ for v := bucket[w]; v != 0; v = bucket[v] {
+ u := eval(v, ancestor, semi, dfnum, best)
+ if semi[u] == semi[v] {
+ idom[v] = fromID[w] // true dominator
+ } else {
+ samedom[v] = u // v has same dominator as u
+ }
+ }
+
+ p := parent[w]
+ s := p // semidominator
+
+ var sp ID
+ // calculate the semidominator of w
+ for _, v := range predFn(fromID[w]) {
+ if dfnum[v.ID] == notFound {
+ // skip unreachable predecessor
+ continue
+ }
+
+ if dfnum[v.ID] <= dfnum[w] {
+ sp = v.ID
+ } else {
+ sp = semi[eval(v.ID, ancestor, semi, dfnum, best)]
+ }
+
+ if dfnum[sp] < dfnum[s] {
+ s = sp
+ }
+ }
+
+ // link
+ ancestor[w] = p
+ best[w] = w
+
+ semi[w] = s
+ if semi[s] != parent[s] {
+ bucket[w] = bucket[s]
+ bucket[s] = w
+ }
+ }
+
+ // Final pass of step 3
+ for v := bucket[0]; v != 0; v = bucket[v] {
+ idom[v] = fromID[bucket[0]]
+ }
+
+ // Step 4. Explictly define the immediate dominator of each vertex,
+ // carrying out the computation vertex by vertex in increasing order by
+ // number.
+ for i := 1; i < maxBlockID-1; i++ {
+ w := vertex[i]
+ if w == 0 {
+ continue
+ }
+ // w has the same dominator as samedom[w]
+ if samedom[w] != 0 {
+ idom[w] = idom[samedom[w]]
+ }
+ }
+ return idom
+}
+
+// eval function from LT paper with path compression
+func eval(v ID, ancestor []ID, semi []ID, dfnum []ID, best []ID) ID {
+ a := ancestor[v]
+ if ancestor[a] != 0 {
+ bid := eval(a, ancestor, semi, dfnum, best)
+ ancestor[v] = ancestor[a]
+ if dfnum[semi[bid]] < dfnum[semi[best[v]]] {
+ best[v] = bid
+ }
+ }
+ return best[v]
+}
+
+// dominators computes the dominator tree for f. It returns a slice
+// which maps block ID to the immediate dominator of that block.
+// Unreachable blocks map to nil. The entry block maps to nil.
+func dominatorsSimple(f *Func) []*Block {
+ // A simple algorithm for now
+ // Cooper, Harvey, Kennedy
+ idom := make([]*Block, f.NumBlocks())
+
+ // Compute postorder walk
+ post := postorder(f)
+
+ // Make map from block id to order index (for intersect call)
+ postnum := make([]int, f.NumBlocks())
+ for i, b := range post {
+ postnum[b.ID] = i
+ }
+
+ // Make the entry block a self-loop
+ idom[f.Entry.ID] = f.Entry
+ if postnum[f.Entry.ID] != len(post)-1 {
+ f.Fatalf("entry block %v not last in postorder", f.Entry)
+ }
+
+ // Compute relaxation of idom entries
+ for {
+ changed := false
+
+ for i := len(post) - 2; i >= 0; i-- {
+ b := post[i]
+ var d *Block
+ for _, p := range b.Preds {
+ if idom[p.ID] == nil {
+ continue
+ }
+ if d == nil {
+ d = p
+ continue
+ }
+ d = intersect(d, p, postnum, idom)
+ }
+ if d != idom[b.ID] {
+ idom[b.ID] = d
+ changed = true
+ }
+ }
+ if !changed {
+ break
+ }
+ }
+ // Set idom of entry block to nil instead of itself.
+ idom[f.Entry.ID] = nil
+ return idom
+}
+
+// intersect finds the closest dominator of both b and c.
+// It requires a postorder numbering of all the blocks.
+func intersect(b, c *Block, postnum []int, idom []*Block) *Block {
+ // TODO: This loop is O(n^2). See BenchmarkNilCheckDeep*.
+ for b != c {
+ if postnum[b.ID] < postnum[c.ID] {
+ b = idom[b.ID]
+ } else {
+ c = idom[c.ID]
+ }
+ }
+ return b
+}
diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go
new file mode 100644
index 0000000..0328655
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/dom_test.go
@@ -0,0 +1,422 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func BenchmarkDominatorsLinear(b *testing.B) { benchmarkDominators(b, 10000, genLinear) }
+func BenchmarkDominatorsFwdBack(b *testing.B) { benchmarkDominators(b, 10000, genFwdBack) }
+func BenchmarkDominatorsManyPred(b *testing.B) { benchmarkDominators(b, 10000, genManyPred) }
+func BenchmarkDominatorsMaxPred(b *testing.B) { benchmarkDominators(b, 10000, genMaxPred) }
+func BenchmarkDominatorsMaxPredVal(b *testing.B) { benchmarkDominators(b, 10000, genMaxPredValue) }
+
+type blockGen func(size int) []bloc
+
+// genLinear creates an array of blocks that succeed one another
+// b_n -> [b_n+1].
+func genLinear(size int) []bloc {
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto(blockn(0)),
+ ),
+ )
+ for i := 0; i < size; i++ {
+ blocs = append(blocs, Bloc(blockn(i),
+ Goto(blockn(i+1))))
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ return blocs
+}
+
+// genLinear creates an array of blocks that alternate between
+// b_n -> [b_n+1], b_n -> [b_n+1, b_n-1] , b_n -> [b_n+1, b_n+2]
+func genFwdBack(size int) []bloc {
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto(blockn(0)),
+ ),
+ )
+ for i := 0; i < size; i++ {
+ switch i % 2 {
+ case 0:
+ blocs = append(blocs, Bloc(blockn(i),
+ If("p", blockn(i+1), blockn(i+2))))
+ case 1:
+ blocs = append(blocs, Bloc(blockn(i),
+ If("p", blockn(i+1), blockn(i-1))))
+ }
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ return blocs
+}
+
+// genManyPred creates an array of blocks where 1/3rd have a sucessor of the
+// first block, 1/3rd the last block, and the remaining third are plain.
+func genManyPred(size int) []bloc {
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto(blockn(0)),
+ ),
+ )
+
+ // We want predecessor lists to be long, so 2/3rds of the blocks have a
+ // sucessor of the first or last block.
+ for i := 0; i < size; i++ {
+ switch i % 3 {
+ case 0:
+ blocs = append(blocs, Bloc(blockn(i),
+ Valu("a", OpConstBool, TypeBool, 1, nil),
+ Goto(blockn(i+1))))
+ case 1:
+ blocs = append(blocs, Bloc(blockn(i),
+ Valu("a", OpConstBool, TypeBool, 1, nil),
+ If("p", blockn(i+1), blockn(0))))
+ case 2:
+ blocs = append(blocs, Bloc(blockn(i),
+ Valu("a", OpConstBool, TypeBool, 1, nil),
+ If("p", blockn(i+1), blockn(size))))
+ }
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ return blocs
+}
+
+// genMaxPred maximizes the size of the 'exit' predecessor list.
+func genMaxPred(size int) []bloc {
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto(blockn(0)),
+ ),
+ )
+
+ for i := 0; i < size; i++ {
+ blocs = append(blocs, Bloc(blockn(i),
+ If("p", blockn(i+1), "exit")))
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ return blocs
+}
+
+// genMaxPredValue is identical to genMaxPred but contains an
+// additional value.
+func genMaxPredValue(size int) []bloc {
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto(blockn(0)),
+ ),
+ )
+
+ for i := 0; i < size; i++ {
+ blocs = append(blocs, Bloc(blockn(i),
+ Valu("a", OpConstBool, TypeBool, 1, nil),
+ If("p", blockn(i+1), "exit")))
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ return blocs
+}
+
+// sink for benchmark
+var domBenchRes []*Block
+
+func benchmarkDominators(b *testing.B, size int, bg blockGen) {
+ c := NewConfig("amd64", DummyFrontend{b}, nil, true)
+ fun := Fun(c, "entry", bg(size)...)
+
+ CheckFunc(fun.f)
+ b.SetBytes(int64(size))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ domBenchRes = dominators(fun.f)
+ }
+}
+
+type domFunc func(f *Func) []*Block
+
+// verifyDominators verifies that the dominators of fut (function under test)
+// as determined by domFn, match the map node->dominator
+func verifyDominators(t *testing.T, fut fun, domFn domFunc, doms map[string]string) {
+ blockNames := map[*Block]string{}
+ for n, b := range fut.blocks {
+ blockNames[b] = n
+ }
+
+ calcDom := domFn(fut.f)
+
+ for n, d := range doms {
+ nblk, ok := fut.blocks[n]
+ if !ok {
+ t.Errorf("invalid block name %s", n)
+ }
+ dblk, ok := fut.blocks[d]
+ if !ok {
+ t.Errorf("invalid block name %s", d)
+ }
+
+ domNode := calcDom[nblk.ID]
+ switch {
+ case calcDom[nblk.ID] == dblk:
+ calcDom[nblk.ID] = nil
+ continue
+ case calcDom[nblk.ID] != dblk:
+ t.Errorf("expected %s as dominator of %s, found %s", d, n, blockNames[domNode])
+ default:
+ t.Fatal("unexpected dominator condition")
+ }
+ }
+
+ for id, d := range calcDom {
+ // If nil, we've already verified it
+ if d == nil {
+ continue
+ }
+ for _, b := range fut.blocks {
+ if int(b.ID) == id {
+ t.Errorf("unexpected dominator of %s for %s", blockNames[d], blockNames[b])
+ }
+ }
+ }
+
+}
+
+func TestDominatorsSingleBlock(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Exit("mem")))
+
+ doms := map[string]string{}
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+
+}
+
+func TestDominatorsSimple(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("a")),
+ Bloc("a",
+ Goto("b")),
+ Bloc("b",
+ Goto("c")),
+ Bloc("c",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ doms := map[string]string{
+ "a": "entry",
+ "b": "a",
+ "c": "b",
+ "exit": "c",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+
+}
+
+func TestDominatorsMultPredFwd(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ If("p", "a", "c")),
+ Bloc("a",
+ If("p", "b", "c")),
+ Bloc("b",
+ Goto("c")),
+ Bloc("c",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ doms := map[string]string{
+ "a": "entry",
+ "b": "a",
+ "c": "entry",
+ "exit": "c",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+}
+
+func TestDominatorsDeadCode(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 0, nil),
+ If("p", "b3", "b5")),
+ Bloc("b2", Exit("mem")),
+ Bloc("b3", Goto("b2")),
+ Bloc("b4", Goto("b2")),
+ Bloc("b5", Goto("b2")))
+
+ doms := map[string]string{
+ "b2": "entry",
+ "b3": "entry",
+ "b5": "entry",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+}
+
+func TestDominatorsMultPredRev(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Goto("first")),
+ Bloc("first",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto("a")),
+ Bloc("a",
+ If("p", "b", "first")),
+ Bloc("b",
+ Goto("c")),
+ Bloc("c",
+ If("p", "exit", "b")),
+ Bloc("exit",
+ Exit("mem")))
+
+ doms := map[string]string{
+ "first": "entry",
+ "a": "first",
+ "b": "a",
+ "c": "b",
+ "exit": "c",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+}
+
+func TestDominatorsMultPred(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ If("p", "a", "c")),
+ Bloc("a",
+ If("p", "b", "c")),
+ Bloc("b",
+ Goto("c")),
+ Bloc("c",
+ If("p", "b", "exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ doms := map[string]string{
+ "a": "entry",
+ "b": "entry",
+ "c": "entry",
+ "exit": "c",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, dominators, doms)
+ verifyDominators(t, fun, dominatorsSimple, doms)
+}
+
+func TestPostDominators(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ If("p", "a", "c")),
+ Bloc("a",
+ If("p", "b", "c")),
+ Bloc("b",
+ Goto("c")),
+ Bloc("c",
+ If("p", "b", "exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ doms := map[string]string{"entry": "c",
+ "a": "c",
+ "b": "c",
+ "c": "exit",
+ }
+
+ CheckFunc(fun.f)
+ verifyDominators(t, fun, postDominators, doms)
+}
+
+func TestInfiniteLoop(t *testing.T) {
+ c := testConfig(t)
+ // note lack of an exit block
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("p", OpConstBool, TypeBool, 1, nil),
+ Goto("a")),
+ Bloc("a",
+ Goto("b")),
+ Bloc("b",
+ Goto("a")))
+
+ CheckFunc(fun.f)
+ doms := map[string]string{"a": "entry",
+ "b": "a"}
+ verifyDominators(t, fun, dominators, doms)
+
+ // no exit block, so there are no post-dominators
+ postDoms := map[string]string{}
+ verifyDominators(t, fun, postDominators, postDoms)
+}
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
new file mode 100644
index 0000000..dae9ed7
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -0,0 +1,67 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "cmd/internal/obj"
+ "testing"
+)
+
+var CheckFunc = checkFunc
+var PrintFunc = printFunc
+var Opt = opt
+var Deadcode = deadcode
+
+func testConfig(t *testing.T) *Config {
+ testCtxt := &obj.Link{}
+ return NewConfig("amd64", DummyFrontend{t}, testCtxt, true)
+}
+
+// DummyFrontend is a test-only frontend.
+// It assumes 64 bit integers and pointers.
+type DummyFrontend struct {
+ t testing.TB
+}
+
+func (DummyFrontend) StringData(s string) interface{} {
+ return nil
+}
+func (DummyFrontend) Auto(t Type) GCNode {
+ return nil
+}
+func (DummyFrontend) Line(line int32) string {
+ return "unknown.go:0"
+}
+
+func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
+func (d DummyFrontend) Log() bool { return true }
+
+func (d DummyFrontend) Fatalf(line int32, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
+func (d DummyFrontend) Unimplementedf(line int32, msg string, args ...interface{}) {
+ d.t.Fatalf(msg, args...)
+}
+func (d DummyFrontend) Warnl(line int, msg string, args ...interface{}) { d.t.Logf(msg, args...) }
+func (d DummyFrontend) Debug_checknil() bool { return false }
+
+func (d DummyFrontend) TypeBool() Type { return TypeBool }
+func (d DummyFrontend) TypeInt8() Type { return TypeInt8 }
+func (d DummyFrontend) TypeInt16() Type { return TypeInt16 }
+func (d DummyFrontend) TypeInt32() Type { return TypeInt32 }
+func (d DummyFrontend) TypeInt64() Type { return TypeInt64 }
+func (d DummyFrontend) TypeUInt8() Type { return TypeUInt8 }
+func (d DummyFrontend) TypeUInt16() Type { return TypeUInt16 }
+func (d DummyFrontend) TypeUInt32() Type { return TypeUInt32 }
+func (d DummyFrontend) TypeUInt64() Type { return TypeUInt64 }
+func (d DummyFrontend) TypeFloat32() Type { return TypeFloat32 }
+func (d DummyFrontend) TypeFloat64() Type { return TypeFloat64 }
+func (d DummyFrontend) TypeInt() Type { return TypeInt64 }
+func (d DummyFrontend) TypeUintptr() Type { return TypeUInt64 }
+func (d DummyFrontend) TypeString() Type { panic("unimplemented") }
+func (d DummyFrontend) TypeBytePtr() Type { return TypeBytePtr }
+
+func (d DummyFrontend) CanSSA(t Type) bool {
+ // There are no un-SSAable types in dummy land.
+ return true
+}
diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go
new file mode 100644
index 0000000..7ed1fe5
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/flagalloc.go
@@ -0,0 +1,131 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+const flagRegMask = regMask(1) << 33 // TODO: arch-specific
+
+// flagalloc allocates the flag register among all the flag-generating
+// instructions. Flag values are recomputed if they need to be
+// spilled/restored.
+func flagalloc(f *Func) {
+ // Compute the in-register flag value we want at the end of
+ // each block. This is basically a best-effort live variable
+ // analysis, so it can be much simpler than a full analysis.
+ // TODO: do we really need to keep flag values live across blocks?
+ // Could we force the flags register to be unused at basic block
+ // boundaries? Then we wouldn't need this computation.
+ end := make([]*Value, f.NumBlocks())
+ for n := 0; n < 2; n++ {
+ // Walk blocks backwards. Poor-man's postorder traversal.
+ for i := len(f.Blocks) - 1; i >= 0; i-- {
+ b := f.Blocks[i]
+ // Walk values backwards to figure out what flag
+ // value we want in the flag register at the start
+ // of the block.
+ flag := end[b.ID]
+ if b.Control != nil && b.Control.Type.IsFlags() {
+ flag = b.Control
+ }
+ for j := len(b.Values) - 1; j >= 0; j-- {
+ v := b.Values[j]
+ if v == flag {
+ flag = nil
+ }
+ if opcodeTable[v.Op].reg.clobbers&flagRegMask != 0 {
+ flag = nil
+ }
+ for _, a := range v.Args {
+ if a.Type.IsFlags() {
+ flag = a
+ }
+ }
+ }
+ if flag != nil {
+ for _, p := range b.Preds {
+ end[p.ID] = flag
+ }
+ }
+ }
+ }
+
+ // For blocks which have a flags control value, that's the only value
+ // we can leave in the flags register at the end of the block. (There
+ // is no place to put a flag regeneration instruction.)
+ for _, b := range f.Blocks {
+ v := b.Control
+ if v != nil && v.Type.IsFlags() && end[b.ID] != v {
+ end[b.ID] = nil
+ }
+ }
+
+ // Add flag recomputations where they are needed.
+ // TODO: Remove original instructions if they are never used.
+ var oldSched []*Value
+ for _, b := range f.Blocks {
+ oldSched = append(oldSched[:0], b.Values...)
+ b.Values = b.Values[:0]
+ // The current live flag value the pre-flagalloc copy).
+ var flag *Value
+ if len(b.Preds) > 0 {
+ flag = end[b.Preds[0].ID]
+ // Note: the following condition depends on the lack of critical edges.
+ for _, p := range b.Preds[1:] {
+ if end[p.ID] != flag {
+ f.Fatalf("live flag in %s's predecessors not consistent", b)
+ }
+ }
+ }
+ for _, v := range oldSched {
+ if v.Op == OpPhi && v.Type.IsFlags() {
+ f.Fatalf("phi of flags not supported: %s", v.LongString())
+ }
+ // Make sure any flag arg of v is in the flags register.
+ // If not, recompute it.
+ for i, a := range v.Args {
+ if !a.Type.IsFlags() {
+ continue
+ }
+ if a == flag {
+ continue
+ }
+ // Recalculate a
+ c := a.copyInto(b)
+ // Update v.
+ v.SetArg(i, c)
+ // Remember the most-recently computed flag value.
+ flag = a
+ }
+ // Issue v.
+ b.Values = append(b.Values, v)
+ if opcodeTable[v.Op].reg.clobbers&flagRegMask != 0 {
+ flag = nil
+ }
+ if v.Type.IsFlags() {
+ flag = v
+ }
+ }
+ if v := b.Control; v != nil && v != flag && v.Type.IsFlags() {
+ // Recalculate control value.
+ c := v.copyInto(b)
+ b.Control = c
+ flag = v
+ }
+ if v := end[b.ID]; v != nil && v != flag {
+ // Need to reissue flag generator for use by
+ // subsequent blocks.
+ _ = v.copyInto(b)
+ // Note: this flag generator is not properly linked up
+ // with the flag users. This breaks the SSA representation.
+ // We could fix up the users with another pass, but for now
+ // we'll just leave it. (Regalloc has the same issue for
+ // standard regs, and it runs next.)
+ }
+ }
+
+ // Save live flag state for later.
+ for _, b := range f.Blocks {
+ b.FlagsLiveAtEnd = end[b.ID] != nil
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
new file mode 100644
index 0000000..7cc5f6c
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -0,0 +1,352 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+ "math"
+)
+
+// A Func represents a Go func declaration (or function literal) and
+// its body. This package compiles each Func independently.
+type Func struct {
+ Config *Config // architecture information
+ pass *pass // current pass information (name, options, etc.)
+ Name string // e.g. bytes·Compare
+ Type Type // type signature of the function.
+ StaticData interface{} // associated static data, untouched by the ssa package
+ Blocks []*Block // unordered set of all basic blocks (note: not indexable by ID)
+ Entry *Block // the entry basic block
+ bid idAlloc // block ID allocator
+ vid idAlloc // value ID allocator
+
+ scheduled bool // Values in Blocks are in final order
+
+ // when register allocation is done, maps value ids to locations
+ RegAlloc []Location
+
+ // map from LocalSlot to set of Values that we want to store in that slot.
+ NamedValues map[LocalSlot][]*Value
+ // Names is a copy of NamedValues.Keys. We keep a separate list
+ // of keys to make iteration order deterministic.
+ Names []LocalSlot
+
+ freeValues *Value // free Values linked by argstorage[0]. All other fields except ID are 0/nil.
+ freeBlocks *Block // free Blocks linked by succstorage[0]. All other fields except ID are 0/nil.
+
+ constants map[int64][]*Value // constants cache, keyed by constant value; users must check value's Op and Type
+}
+
+// NumBlocks returns an integer larger than the id of any Block in the Func.
+func (f *Func) NumBlocks() int {
+ return f.bid.num()
+}
+
+// NumValues returns an integer larger than the id of any Value in the Func.
+func (f *Func) NumValues() int {
+ return f.vid.num()
+}
+
+// newSparseSet returns a sparse set that can store at least up to n integers.
+func (f *Func) newSparseSet(n int) *sparseSet {
+ for i, scr := range f.Config.scrSparse {
+ if scr != nil && scr.cap() >= n {
+ f.Config.scrSparse[i] = nil
+ scr.clear()
+ return scr
+ }
+ }
+ return newSparseSet(n)
+}
+
+// retSparseSet returns a sparse set to the config's cache of sparse sets to be reused by f.newSparseSet.
+func (f *Func) retSparseSet(ss *sparseSet) {
+ for i, scr := range f.Config.scrSparse {
+ if scr == nil {
+ f.Config.scrSparse[i] = ss
+ return
+ }
+ }
+ f.Config.scrSparse = append(f.Config.scrSparse, ss)
+}
+
+// newValue allocates a new Value with the given fields and places it at the end of b.Values.
+func (f *Func) newValue(op Op, t Type, b *Block, line int32) *Value {
+ var v *Value
+ if f.freeValues != nil {
+ v = f.freeValues
+ f.freeValues = v.argstorage[0]
+ v.argstorage[0] = nil
+ } else {
+ ID := f.vid.get()
+ if int(ID) < len(f.Config.values) {
+ v = &f.Config.values[ID]
+ } else {
+ v = &Value{ID: ID}
+ }
+ }
+ v.Op = op
+ v.Type = t
+ v.Block = b
+ v.Line = line
+ b.Values = append(b.Values, v)
+ return v
+}
+
+// logPassStat writes a string key and int value as a warning in a
+// tab-separated format easily handled by spreadsheets or awk.
+// file names, lines, and function names are included to provide enough (?)
+// context to allow item-by-item comparisons across runs.
+// For example:
+// awk 'BEGIN {FS="\t"} $3~/TIME/{sum+=$4} END{print "t(ns)=",sum}' t.log
+func (f *Func) logStat(key string, args ...interface{}) {
+ value := ""
+ for _, a := range args {
+ value += fmt.Sprintf("\t%v", a)
+ }
+ f.Config.Warnl(int(f.Entry.Line), "\t%s\t%s%s\t%s", f.pass.name, key, value, f.Name)
+}
+
+// freeValue frees a value. It must no longer be referenced.
+func (f *Func) freeValue(v *Value) {
+ if v.Block == nil {
+ f.Fatalf("trying to free an already freed value")
+ }
+ // Clear everything but ID (which we reuse).
+ id := v.ID
+ *v = Value{}
+ v.ID = id
+ v.argstorage[0] = f.freeValues
+ f.freeValues = v
+}
+
+// newBlock allocates a new Block of the given kind and places it at the end of f.Blocks.
+func (f *Func) NewBlock(kind BlockKind) *Block {
+ var b *Block
+ if f.freeBlocks != nil {
+ b = f.freeBlocks
+ f.freeBlocks = b.succstorage[0]
+ b.succstorage[0] = nil
+ } else {
+ ID := f.bid.get()
+ if int(ID) < len(f.Config.blocks) {
+ b = &f.Config.blocks[ID]
+ } else {
+ b = &Block{ID: ID}
+ }
+ }
+ b.Kind = kind
+ b.Func = f
+ b.Preds = b.predstorage[:0]
+ b.Succs = b.succstorage[:0]
+ b.Values = b.valstorage[:0]
+ f.Blocks = append(f.Blocks, b)
+ return b
+}
+
+func (f *Func) freeBlock(b *Block) {
+ if b.Func == nil {
+ f.Fatalf("trying to free an already freed block")
+ }
+ // Clear everything but ID (which we reuse).
+ id := b.ID
+ *b = Block{}
+ b.ID = id
+ b.succstorage[0] = f.freeBlocks
+ f.freeBlocks = b
+}
+
+// NewValue0 returns a new value in the block with no arguments and zero aux values.
+func (b *Block) NewValue0(line int32, op Op, t Type) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Args = v.argstorage[:0]
+ return v
+}
+
+// NewValue returns a new value in the block with no arguments and an auxint value.
+func (b *Block) NewValue0I(line int32, op Op, t Type, auxint int64) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Args = v.argstorage[:0]
+ return v
+}
+
+// NewValue returns a new value in the block with no arguments and an aux value.
+func (b *Block) NewValue0A(line int32, op Op, t Type, aux interface{}) *Value {
+ if _, ok := aux.(int64); ok {
+ // Disallow int64 aux values. They should be in the auxint field instead.
+ // Maybe we want to allow this at some point, but for now we disallow it
+ // to prevent errors like using NewValue1A instead of NewValue1I.
+ b.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux)
+ }
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Aux = aux
+ v.Args = v.argstorage[:0]
+ return v
+}
+
+// NewValue returns a new value in the block with no arguments and both an auxint and aux values.
+func (b *Block) NewValue0IA(line int32, op Op, t Type, auxint int64, aux interface{}) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Aux = aux
+ v.Args = v.argstorage[:0]
+ return v
+}
+
+// NewValue1 returns a new value in the block with one argument and zero aux values.
+func (b *Block) NewValue1(line int32, op Op, t Type, arg *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Args = v.argstorage[:1]
+ v.argstorage[0] = arg
+ return v
+}
+
+// NewValue1I returns a new value in the block with one argument and an auxint value.
+func (b *Block) NewValue1I(line int32, op Op, t Type, auxint int64, arg *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Args = v.argstorage[:1]
+ v.argstorage[0] = arg
+ return v
+}
+
+// NewValue1A returns a new value in the block with one argument and an aux value.
+func (b *Block) NewValue1A(line int32, op Op, t Type, aux interface{}, arg *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Aux = aux
+ v.Args = v.argstorage[:1]
+ v.argstorage[0] = arg
+ return v
+}
+
+// NewValue1IA returns a new value in the block with one argument and both an auxint and aux values.
+func (b *Block) NewValue1IA(line int32, op Op, t Type, auxint int64, aux interface{}, arg *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Aux = aux
+ v.Args = v.argstorage[:1]
+ v.argstorage[0] = arg
+ return v
+}
+
+// NewValue2 returns a new value in the block with two arguments and zero aux values.
+func (b *Block) NewValue2(line int32, op Op, t Type, arg0, arg1 *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Args = v.argstorage[:2]
+ v.argstorage[0] = arg0
+ v.argstorage[1] = arg1
+ return v
+}
+
+// NewValue2I returns a new value in the block with two arguments and an auxint value.
+func (b *Block) NewValue2I(line int32, op Op, t Type, auxint int64, arg0, arg1 *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Args = v.argstorage[:2]
+ v.argstorage[0] = arg0
+ v.argstorage[1] = arg1
+ return v
+}
+
+// NewValue3 returns a new value in the block with three arguments and zero aux values.
+func (b *Block) NewValue3(line int32, op Op, t Type, arg0, arg1, arg2 *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = 0
+ v.Args = []*Value{arg0, arg1, arg2}
+ return v
+}
+
+// NewValue3I returns a new value in the block with three arguments and an auxint value.
+func (b *Block) NewValue3I(line int32, op Op, t Type, auxint int64, arg0, arg1, arg2 *Value) *Value {
+ v := b.Func.newValue(op, t, b, line)
+ v.AuxInt = auxint
+ v.Args = []*Value{arg0, arg1, arg2}
+ return v
+}
+
+// constVal returns a constant value for c.
+func (f *Func) constVal(line int32, op Op, t Type, c int64) *Value {
+ if f.constants == nil {
+ f.constants = make(map[int64][]*Value)
+ }
+ vv := f.constants[c]
+ for _, v := range vv {
+ if v.Op == op && v.Type.Equal(t) {
+ return v
+ }
+ }
+ v := f.Entry.NewValue0I(line, op, t, c)
+ f.constants[c] = append(vv, v)
+ return v
+}
+
+// ConstInt returns an int constant representing its argument.
+func (f *Func) ConstBool(line int32, t Type, c bool) *Value {
+ i := int64(0)
+ if c {
+ i = 1
+ }
+ return f.constVal(line, OpConstBool, t, i)
+}
+func (f *Func) ConstInt8(line int32, t Type, c int8) *Value {
+ return f.constVal(line, OpConst8, t, int64(c))
+}
+func (f *Func) ConstInt16(line int32, t Type, c int16) *Value {
+ return f.constVal(line, OpConst16, t, int64(c))
+}
+func (f *Func) ConstInt32(line int32, t Type, c int32) *Value {
+ return f.constVal(line, OpConst32, t, int64(c))
+}
+func (f *Func) ConstInt64(line int32, t Type, c int64) *Value {
+ return f.constVal(line, OpConst64, t, c)
+}
+func (f *Func) ConstFloat32(line int32, t Type, c float64) *Value {
+ return f.constVal(line, OpConst32F, t, int64(math.Float64bits(c)))
+}
+func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value {
+ return f.constVal(line, OpConst64F, t, int64(math.Float64bits(c)))
+}
+
+func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) }
+func (f *Func) Log() bool { return f.Config.Log() }
+func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(f.Entry.Line, msg, args...) }
+func (f *Func) Unimplementedf(msg string, args ...interface{}) {
+ f.Config.Unimplementedf(f.Entry.Line, msg, args...)
+}
+
+func (f *Func) Free() {
+ // Clear values.
+ n := f.vid.num()
+ if n > len(f.Config.values) {
+ n = len(f.Config.values)
+ }
+ for i := 1; i < n; i++ {
+ f.Config.values[i] = Value{}
+ f.Config.values[i].ID = ID(i)
+ }
+
+ // Clear blocks.
+ n = f.bid.num()
+ if n > len(f.Config.blocks) {
+ n = len(f.Config.blocks)
+ }
+ for i := 1; i < n; i++ {
+ f.Config.blocks[i] = Block{}
+ f.Config.blocks[i].ID = ID(i)
+ }
+
+ // Unregister from config.
+ if f.Config.curFunc != f {
+ f.Fatalf("free of function which isn't the last one allocated")
+ }
+ f.Config.curFunc = nil
+ *f = Func{} // just in case
+}
diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go
new file mode 100644
index 0000000..fa6a1a8
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/func_test.go
@@ -0,0 +1,445 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains some utility functions to help define Funcs for testing.
+// As an example, the following func
+//
+// b1:
+// v1 = InitMem <mem>
+// Plain -> b2
+// b2:
+// Exit v1
+// b3:
+// v2 = Const <bool> [true]
+// If v2 -> b3 b2
+//
+// can be defined as
+//
+// fun := Fun("entry",
+// Bloc("entry",
+// Valu("mem", OpInitMem, TypeMem, 0, nil),
+// Goto("exit")),
+// Bloc("exit",
+// Exit("mem")),
+// Bloc("deadblock",
+// Valu("deadval", OpConstBool, TypeBool, 0, true),
+// If("deadval", "deadblock", "exit")))
+//
+// and the Blocks or Values used in the Func can be accessed
+// like this:
+// fun.blocks["entry"] or fun.values["deadval"]
+
+package ssa
+
+// TODO(matloob): Choose better names for Fun, Bloc, Goto, etc.
+// TODO(matloob): Write a parser for the Func disassembly. Maybe
+// the parser can be used instead of Fun.
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+)
+
+// Compare two Funcs for equivalence. Their CFGs must be isomorphic,
+// and their values must correspond.
+// Requires that values and predecessors are in the same order, even
+// though Funcs could be equivalent when they are not.
+// TODO(matloob): Allow values and predecessors to be in different
+// orders if the CFG are otherwise equivalent.
+func Equiv(f, g *Func) bool {
+ valcor := make(map[*Value]*Value)
+ var checkVal func(fv, gv *Value) bool
+ checkVal = func(fv, gv *Value) bool {
+ if fv == nil && gv == nil {
+ return true
+ }
+ if valcor[fv] == nil && valcor[gv] == nil {
+ valcor[fv] = gv
+ valcor[gv] = fv
+ // Ignore ids. Ops and Types are compared for equality.
+ // TODO(matloob): Make sure types are canonical and can
+ // be compared for equality.
+ if fv.Op != gv.Op || fv.Type != gv.Type || fv.AuxInt != gv.AuxInt {
+ return false
+ }
+ if !reflect.DeepEqual(fv.Aux, gv.Aux) {
+ // This makes the assumption that aux values can be compared
+ // using DeepEqual.
+ // TODO(matloob): Aux values may be *gc.Sym pointers in the near
+ // future. Make sure they are canonical.
+ return false
+ }
+ if len(fv.Args) != len(gv.Args) {
+ return false
+ }
+ for i := range fv.Args {
+ if !checkVal(fv.Args[i], gv.Args[i]) {
+ return false
+ }
+ }
+ }
+ return valcor[fv] == gv && valcor[gv] == fv
+ }
+ blkcor := make(map[*Block]*Block)
+ var checkBlk func(fb, gb *Block) bool
+ checkBlk = func(fb, gb *Block) bool {
+ if blkcor[fb] == nil && blkcor[gb] == nil {
+ blkcor[fb] = gb
+ blkcor[gb] = fb
+ // ignore ids
+ if fb.Kind != gb.Kind {
+ return false
+ }
+ if len(fb.Values) != len(gb.Values) {
+ return false
+ }
+ for i := range fb.Values {
+ if !checkVal(fb.Values[i], gb.Values[i]) {
+ return false
+ }
+ }
+ if len(fb.Succs) != len(gb.Succs) {
+ return false
+ }
+ for i := range fb.Succs {
+ if !checkBlk(fb.Succs[i], gb.Succs[i]) {
+ return false
+ }
+ }
+ if len(fb.Preds) != len(gb.Preds) {
+ return false
+ }
+ for i := range fb.Preds {
+ if !checkBlk(fb.Preds[i], gb.Preds[i]) {
+ return false
+ }
+ }
+ return true
+
+ }
+ return blkcor[fb] == gb && blkcor[gb] == fb
+ }
+
+ return checkBlk(f.Entry, g.Entry)
+}
+
+// fun is the return type of Fun. It contains the created func
+// itself as well as indexes from block and value names into the
+// corresponding Blocks and Values.
+type fun struct {
+ f *Func
+ blocks map[string]*Block
+ values map[string]*Value
+}
+
+var emptyPass pass = pass{
+ name: "empty pass",
+}
+
+// Fun takes the name of an entry bloc and a series of Bloc calls, and
+// returns a fun containing the composed Func. entry must be a name
+// supplied to one of the Bloc functions. Each of the bloc names and
+// valu names should be unique across the Fun.
+func Fun(c *Config, entry string, blocs ...bloc) fun {
+ f := c.NewFunc()
+ f.pass = &emptyPass
+
+ blocks := make(map[string]*Block)
+ values := make(map[string]*Value)
+ // Create all the blocks and values.
+ for _, bloc := range blocs {
+ b := f.NewBlock(bloc.control.kind)
+ blocks[bloc.name] = b
+ for _, valu := range bloc.valus {
+ // args are filled in the second pass.
+ values[valu.name] = b.NewValue0IA(0, valu.op, valu.t, valu.auxint, valu.aux)
+ }
+ }
+ // Connect the blocks together and specify control values.
+ f.Entry = blocks[entry]
+ for _, bloc := range blocs {
+ b := blocks[bloc.name]
+ c := bloc.control
+ // Specify control values.
+ if c.control != "" {
+ cval, ok := values[c.control]
+ if !ok {
+ f.Fatalf("control value for block %s missing", bloc.name)
+ }
+ b.Control = cval
+ }
+ // Fill in args.
+ for _, valu := range bloc.valus {
+ v := values[valu.name]
+ for _, arg := range valu.args {
+ a, ok := values[arg]
+ if !ok {
+ b.Fatalf("arg %s missing for value %s in block %s",
+ arg, valu.name, bloc.name)
+ }
+ v.AddArg(a)
+ }
+ }
+ // Connect to successors.
+ for _, succ := range c.succs {
+ b.AddEdgeTo(blocks[succ])
+ }
+ }
+ return fun{f, blocks, values}
+}
+
+// Bloc defines a block for Fun. The bloc name should be unique
+// across the containing Fun. entries should consist of calls to valu,
+// as well as one call to Goto, If, or Exit to specify the block kind.
+func Bloc(name string, entries ...interface{}) bloc {
+ b := bloc{}
+ b.name = name
+ seenCtrl := false
+ for _, e := range entries {
+ switch v := e.(type) {
+ case ctrl:
+ // there should be exactly one Ctrl entry.
+ if seenCtrl {
+ panic(fmt.Sprintf("already seen control for block %s", name))
+ }
+ b.control = v
+ seenCtrl = true
+ case valu:
+ b.valus = append(b.valus, v)
+ }
+ }
+ if !seenCtrl {
+ panic(fmt.Sprintf("block %s doesn't have control", b.name))
+ }
+ return b
+}
+
+// Valu defines a value in a block.
+func Valu(name string, op Op, t Type, auxint int64, aux interface{}, args ...string) valu {
+ return valu{name, op, t, auxint, aux, args}
+}
+
+// Goto specifies that this is a BlockPlain and names the single successor.
+// TODO(matloob): choose a better name.
+func Goto(succ string) ctrl {
+ return ctrl{BlockPlain, "", []string{succ}}
+}
+
+// If specifies a BlockIf.
+func If(cond, sub, alt string) ctrl {
+ return ctrl{BlockIf, cond, []string{sub, alt}}
+}
+
+// Exit specifies a BlockExit.
+func Exit(arg string) ctrl {
+ return ctrl{BlockExit, arg, []string{}}
+}
+
+// Eq specifies a BlockAMD64EQ.
+func Eq(cond, sub, alt string) ctrl {
+ return ctrl{BlockAMD64EQ, cond, []string{sub, alt}}
+}
+
+// bloc, ctrl, and valu are internal structures used by Bloc, Valu, Goto,
+// If, and Exit to help define blocks.
+
+type bloc struct {
+ name string
+ control ctrl
+ valus []valu
+}
+
+type ctrl struct {
+ kind BlockKind
+ control string
+ succs []string
+}
+
+type valu struct {
+ name string
+ op Op
+ t Type
+ auxint int64
+ aux interface{}
+ args []string
+}
+
+func TestArgs(t *testing.T) {
+ c := testConfig(t)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+ sum := fun.values["sum"]
+ for i, name := range []string{"a", "b"} {
+ if sum.Args[i] != fun.values[name] {
+ t.Errorf("arg %d for sum is incorrect: want %s, got %s",
+ i, sum.Args[i], fun.values[name])
+ }
+ }
+}
+
+func TestEquiv(t *testing.T) {
+ equivalentCases := []struct{ f, g fun }{
+ // simple case
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem"))),
+ },
+ // block order changed
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("exit",
+ Exit("mem")),
+ Bloc("entry",
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit"))),
+ },
+ }
+ for _, c := range equivalentCases {
+ if !Equiv(c.f.f, c.g.f) {
+ t.Error("expected equivalence. Func definitions:")
+ t.Error(c.f.f)
+ t.Error(c.g.f)
+ }
+ }
+
+ differentCases := []struct{ f, g fun }{
+ // different shape
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Exit("mem"))),
+ },
+ // value order changed
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Exit("mem"))),
+ },
+ // value auxint different
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 26, nil),
+ Exit("mem"))),
+ },
+ // value aux different
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 0, 14),
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 0, 26),
+ Exit("mem"))),
+ },
+ // value args different
+ {
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 14, nil),
+ Valu("b", OpConst64, TypeInt64, 26, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"),
+ Exit("mem"))),
+ Fun(testConfig(t), "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("a", OpConst64, TypeInt64, 0, nil),
+ Valu("b", OpConst64, TypeInt64, 14, nil),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "b", "a"),
+ Exit("mem"))),
+ },
+ }
+ for _, c := range differentCases {
+ if Equiv(c.f.f, c.g.f) {
+ t.Error("expected difference. Func definitions:")
+ t.Error(c.f.f)
+ t.Error(c.g.f)
+ }
+ }
+}
+
+// opcodeMap returns a map from opcode to the number of times that opcode
+// appears in the function.
+func opcodeMap(f *Func) map[Op]int {
+ m := map[Op]int{}
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ m[v.Op]++
+ }
+ }
+ return m
+}
+
+// opcodeCounts checks that the number of opcodes listed in m agree with the
+// number of opcodes that appear in the function.
+func checkOpcodeCounts(t *testing.T, f *Func, m map[Op]int) {
+ n := opcodeMap(f)
+ for op, cnt := range m {
+ if n[op] != cnt {
+ t.Errorf("%s appears %d times, want %d times", op, n[op], cnt)
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go
new file mode 100644
index 0000000..3f81e45
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/fuse.go
@@ -0,0 +1,158 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// fuse simplifies control flow by joining basic blocks.
+func fuse(f *Func) {
+ for changed := true; changed; {
+ changed = false
+ for _, b := range f.Blocks {
+ changed = fuseBlockIf(b) || changed
+ changed = fuseBlockPlain(b) || changed
+ }
+ }
+}
+
+// fuseBlockIf handles the following cases where s0 and s1 are empty blocks.
+//
+// b b b b
+// / \ | \ / | | |
+// s0 s1 | s1 s0 | | |
+// \ / | / \ | | |
+// ss ss ss ss
+//
+// If all Phi ops in ss have identical variables for slots corresponding to
+// s0, s1 and b then the branch can be dropped.
+// TODO: If ss doesn't contain any OpPhis, are s0 and s1 dead code anyway.
+func fuseBlockIf(b *Block) bool {
+ if b.Kind != BlockIf {
+ return false
+ }
+
+ var ss0, ss1 *Block
+ s0 := b.Succs[0]
+ if s0.Kind != BlockPlain || len(s0.Preds) != 1 || len(s0.Values) != 0 {
+ s0, ss0 = b, s0
+ } else {
+ ss0 = s0.Succs[0]
+ }
+ s1 := b.Succs[1]
+ if s1.Kind != BlockPlain || len(s1.Preds) != 1 || len(s1.Values) != 0 {
+ s1, ss1 = b, s1
+ } else {
+ ss1 = s1.Succs[0]
+ }
+
+ if ss0 != ss1 {
+ return false
+ }
+ ss := ss0
+
+ // s0 and s1 are equal with b if the corresponding block is missing
+ // (2nd, 3rd and 4th case in the figure).
+ i0, i1 := -1, -1
+ for i, p := range ss.Preds {
+ if p == s0 {
+ i0 = i
+ }
+ if p == s1 {
+ i1 = i
+ }
+ }
+ if i0 == -1 || i1 == -1 {
+ b.Fatalf("invalid predecessors")
+ }
+ for _, v := range ss.Values {
+ if v.Op == OpPhi && v.Args[i0] != v.Args[i1] {
+ return false
+ }
+ }
+
+ // Now we have two of following b->ss, b->s0->ss and b->s1->ss,
+ // with s0 and s1 empty if exist.
+ // We can replace it with b->ss without if all OpPhis in ss
+ // have identical predecessors (verified above).
+ // No critical edge is introduced because b will have one successor.
+ if s0 != b && s1 != b {
+ ss.removePred(s0)
+
+ // Replace edge b->s1->ss with b->ss.
+ // We need to keep a slot for Phis corresponding to b.
+ for i := range b.Succs {
+ if b.Succs[i] == s1 {
+ b.Succs[i] = ss
+ }
+ }
+ for i := range ss.Preds {
+ if ss.Preds[i] == s1 {
+ ss.Preds[i] = b
+ }
+ }
+ } else if s0 != b {
+ ss.removePred(s0)
+ } else if s1 != b {
+ ss.removePred(s1)
+ }
+ b.Kind = BlockPlain
+ b.Control = nil
+ b.Succs = append(b.Succs[:0], ss)
+
+ // Trash the empty blocks s0 & s1.
+ if s0 != b {
+ s0.Kind = BlockInvalid
+ s0.Values = nil
+ s0.Succs = nil
+ s0.Preds = nil
+ }
+ if s1 != b {
+ s1.Kind = BlockInvalid
+ s1.Values = nil
+ s1.Succs = nil
+ s1.Preds = nil
+ }
+ return true
+}
+
+func fuseBlockPlain(b *Block) bool {
+ if b.Kind != BlockPlain {
+ return false
+ }
+
+ c := b.Succs[0]
+ if len(c.Preds) != 1 {
+ return false
+ }
+
+ // move all of b'c values to c.
+ for _, v := range b.Values {
+ v.Block = c
+ c.Values = append(c.Values, v)
+ }
+
+ // replace b->c edge with preds(b) -> c
+ c.predstorage[0] = nil
+ if len(b.Preds) > len(b.predstorage) {
+ c.Preds = b.Preds
+ } else {
+ c.Preds = append(c.predstorage[:0], b.Preds...)
+ }
+ for _, p := range c.Preds {
+ for i, q := range p.Succs {
+ if q == b {
+ p.Succs[i] = c
+ }
+ }
+ }
+ if f := b.Func; f.Entry == b {
+ f.Entry = c
+ }
+
+ // trash b, just in case
+ b.Kind = BlockInvalid
+ b.Values = nil
+ b.Preds = nil
+ b.Succs = nil
+ return true
+}
diff --git a/src/cmd/compile/internal/ssa/fuse_test.go b/src/cmd/compile/internal/ssa/fuse_test.go
new file mode 100644
index 0000000..937fb71
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/fuse_test.go
@@ -0,0 +1,129 @@
+package ssa
+
+import (
+ "testing"
+)
+
+func TestFuseEliminatesOneBranch(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("nilptr", OpConstNil, ptrType, 0, nil),
+ Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"),
+ If("bool1", "then", "exit")),
+ Bloc("then",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ fuse(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["then"] && b.Kind != BlockInvalid {
+ t.Errorf("then was not eliminated, but should have")
+ }
+ }
+}
+
+func TestFuseEliminatesBothBranches(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("nilptr", OpConstNil, ptrType, 0, nil),
+ Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"),
+ If("bool1", "then", "else")),
+ Bloc("then",
+ Goto("exit")),
+ Bloc("else",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ fuse(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["then"] && b.Kind != BlockInvalid {
+ t.Errorf("then was not eliminated, but should have")
+ }
+ if b == fun.blocks["else"] && b.Kind != BlockInvalid {
+ t.Errorf("then was not eliminated, but should have")
+ }
+ }
+}
+
+func TestFuseHandlesPhis(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("nilptr", OpConstNil, ptrType, 0, nil),
+ Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"),
+ If("bool1", "then", "else")),
+ Bloc("then",
+ Goto("exit")),
+ Bloc("else",
+ Goto("exit")),
+ Bloc("exit",
+ Valu("phi", OpPhi, ptrType, 0, nil, "ptr1", "ptr1"),
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ fuse(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["then"] && b.Kind != BlockInvalid {
+ t.Errorf("then was not eliminated, but should have")
+ }
+ if b == fun.blocks["else"] && b.Kind != BlockInvalid {
+ t.Errorf("then was not eliminated, but should have")
+ }
+ }
+}
+
+func TestFuseEliminatesEmptyBlocks(t *testing.T) {
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("z0")),
+ Bloc("z1",
+ Goto("z2")),
+ Bloc("z3",
+ Goto("exit")),
+ Bloc("z2",
+ Goto("z3")),
+ Bloc("z0",
+ Goto("z1")),
+ Bloc("exit",
+ Exit("mem"),
+ ))
+
+ CheckFunc(fun.f)
+ fuse(fun.f)
+
+ for k, b := range fun.blocks {
+ if k[:1] == "z" && b.Kind != BlockInvalid {
+ t.Errorf("%s was not eliminated, but should have", k)
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
new file mode 100644
index 0000000..167ec82
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -0,0 +1,1164 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// x86 register conventions:
+// - Integer types live in the low portion of registers. Upper portions are junk.
+// - Boolean types use the low-order byte of a register. Upper bytes are junk.
+// - We do not use AH,BH,CH,DH registers.
+// - Floating-point types will live in the low natural slot of an sse2 register.
+// Unused portions are junk.
+
+// Lowering arithmetic
+(Add64 x y) -> (ADDQ x y)
+(AddPtr x y) -> (ADDQ x y)
+(Add32 x y) -> (ADDL x y)
+(Add16 x y) -> (ADDW x y)
+(Add8 x y) -> (ADDB x y)
+(Add32F x y) -> (ADDSS x y)
+(Add64F x y) -> (ADDSD x y)
+
+(Sub64 x y) -> (SUBQ x y)
+(SubPtr x y) -> (SUBQ x y)
+(Sub32 x y) -> (SUBL x y)
+(Sub16 x y) -> (SUBW x y)
+(Sub8 x y) -> (SUBB x y)
+(Sub32F x y) -> (SUBSS x y)
+(Sub64F x y) -> (SUBSD x y)
+
+(Mul64 x y) -> (MULQ x y)
+(Mul32 x y) -> (MULL x y)
+(Mul16 x y) -> (MULW x y)
+(Mul8 x y) -> (MULB x y)
+(Mul32F x y) -> (MULSS x y)
+(Mul64F x y) -> (MULSD x y)
+
+(Div32F x y) -> (DIVSS x y)
+(Div64F x y) -> (DIVSD x y)
+
+(Div64 x y) -> (DIVQ x y)
+(Div64u x y) -> (DIVQU x y)
+(Div32 x y) -> (DIVL x y)
+(Div32u x y) -> (DIVLU x y)
+(Div16 x y) -> (DIVW x y)
+(Div16u x y) -> (DIVWU x y)
+(Div8 x y) -> (DIVW (SignExt8to16 x) (SignExt8to16 y))
+(Div8u x y) -> (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
+
+(Hmul64 x y) -> (HMULQ x y)
+(Hmul64u x y) -> (HMULQU x y)
+(Hmul32 x y) -> (HMULL x y)
+(Hmul32u x y) -> (HMULLU x y)
+(Hmul16 x y) -> (HMULW x y)
+(Hmul16u x y) -> (HMULWU x y)
+(Hmul8 x y) -> (HMULB x y)
+(Hmul8u x y) -> (HMULBU x y)
+
+(Avg64u x y) -> (AVGQU x y)
+
+(Mod64 x y) -> (MODQ x y)
+(Mod64u x y) -> (MODQU x y)
+(Mod32 x y) -> (MODL x y)
+(Mod32u x y) -> (MODLU x y)
+(Mod16 x y) -> (MODW x y)
+(Mod16u x y) -> (MODWU x y)
+(Mod8 x y) -> (MODW (SignExt8to16 x) (SignExt8to16 y))
+(Mod8u x y) -> (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
+
+(And64 x y) -> (ANDQ x y)
+(And32 x y) -> (ANDL x y)
+(And16 x y) -> (ANDW x y)
+(And8 x y) -> (ANDB x y)
+
+(Or64 x y) -> (ORQ x y)
+(Or32 x y) -> (ORL x y)
+(Or16 x y) -> (ORW x y)
+(Or8 x y) -> (ORB x y)
+
+(Xor64 x y) -> (XORQ x y)
+(Xor32 x y) -> (XORL x y)
+(Xor16 x y) -> (XORW x y)
+(Xor8 x y) -> (XORB x y)
+
+(Neg64 x) -> (NEGQ x)
+(Neg32 x) -> (NEGL x)
+(Neg16 x) -> (NEGW x)
+(Neg8 x) -> (NEGB x)
+(Neg32F x) -> (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))]))
+(Neg64F x) -> (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+
+(Com64 x) -> (NOTQ x)
+(Com32 x) -> (NOTL x)
+(Com16 x) -> (NOTW x)
+(Com8 x) -> (NOTB x)
+
+(Sqrt x) -> (SQRTSD x)
+
+// Note: we always extend to 64 bits even though some ops don't need that many result bits.
+(SignExt8to16 x) -> (MOVBQSX x)
+(SignExt8to32 x) -> (MOVBQSX x)
+(SignExt8to64 x) -> (MOVBQSX x)
+(SignExt16to32 x) -> (MOVWQSX x)
+(SignExt16to64 x) -> (MOVWQSX x)
+(SignExt32to64 x) -> (MOVLQSX x)
+
+(ZeroExt8to16 x) -> (MOVBQZX x)
+(ZeroExt8to32 x) -> (MOVBQZX x)
+(ZeroExt8to64 x) -> (MOVBQZX x)
+(ZeroExt16to32 x) -> (MOVWQZX x)
+(ZeroExt16to64 x) -> (MOVWQZX x)
+(ZeroExt32to64 x) -> (MOVLQZX x)
+
+(Cvt32to32F x) -> (CVTSL2SS x)
+(Cvt32to64F x) -> (CVTSL2SD x)
+(Cvt64to32F x) -> (CVTSQ2SS x)
+(Cvt64to64F x) -> (CVTSQ2SD x)
+
+(Cvt32Fto32 x) -> (CVTTSS2SL x)
+(Cvt32Fto64 x) -> (CVTTSS2SQ x)
+(Cvt64Fto32 x) -> (CVTTSD2SL x)
+(Cvt64Fto64 x) -> (CVTTSD2SQ x)
+
+(Cvt32Fto64F x) -> (CVTSS2SD x)
+(Cvt64Fto32F x) -> (CVTSD2SS x)
+
+// Because we ignore high parts of registers, truncates are just copies.
+(Trunc16to8 x) -> x
+(Trunc32to8 x) -> x
+(Trunc32to16 x) -> x
+(Trunc64to8 x) -> x
+(Trunc64to16 x) -> x
+(Trunc64to32 x) -> x
+
+// Lowering shifts
+// Unsigned shifts need to return 0 if shift amount is >= width of shifted value.
+// result = (arg << shift) & (shift >= argbits ? 0 : 0xffffffffffffffff)
+// Note: for small shifts we generate 32 bits of mask even when we don't need it all.
+(Lsh64x64 <t> x y) -> (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
+(Lsh64x32 <t> x y) -> (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
+(Lsh64x16 <t> x y) -> (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
+(Lsh64x8 <t> x y) -> (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
+
+(Lsh32x64 <t> x y) -> (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
+(Lsh32x32 <t> x y) -> (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
+(Lsh32x16 <t> x y) -> (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
+(Lsh32x8 <t> x y) -> (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
+
+(Lsh16x64 <t> x y) -> (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
+(Lsh16x32 <t> x y) -> (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
+(Lsh16x16 <t> x y) -> (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
+(Lsh16x8 <t> x y) -> (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
+
+(Lsh8x64 <t> x y) -> (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
+(Lsh8x32 <t> x y) -> (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
+(Lsh8x16 <t> x y) -> (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
+(Lsh8x8 <t> x y) -> (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
+
+(Lrot64 <t> x [c]) -> (ROLQconst <t> [c&63] x)
+(Lrot32 <t> x [c]) -> (ROLLconst <t> [c&31] x)
+(Lrot16 <t> x [c]) -> (ROLWconst <t> [c&15] x)
+(Lrot8 <t> x [c]) -> (ROLBconst <t> [c&7] x)
+
+(Rsh64Ux64 <t> x y) -> (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
+(Rsh64Ux32 <t> x y) -> (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
+(Rsh64Ux16 <t> x y) -> (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
+(Rsh64Ux8 <t> x y) -> (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
+
+(Rsh32Ux64 <t> x y) -> (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
+(Rsh32Ux32 <t> x y) -> (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
+(Rsh32Ux16 <t> x y) -> (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
+(Rsh32Ux8 <t> x y) -> (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
+
+(Rsh16Ux64 <t> x y) -> (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
+(Rsh16Ux32 <t> x y) -> (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
+(Rsh16Ux16 <t> x y) -> (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
+(Rsh16Ux8 <t> x y) -> (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
+
+(Rsh8Ux64 <t> x y) -> (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
+(Rsh8Ux32 <t> x y) -> (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
+(Rsh8Ux16 <t> x y) -> (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
+(Rsh8Ux8 <t> x y) -> (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
+
+// Signed right shift needs to return 0/-1 if shift amount is >= width of shifted value.
+// We implement this by setting the shift value to -1 (all ones) if the shift value is >= width.
+// Note: for small shift widths we generate 32 bits of mask even when we don't need it all.
+(Rsh64x64 <t> x y) -> (SARQ <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [64])))))
+(Rsh64x32 <t> x y) -> (SARQ <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [64])))))
+(Rsh64x16 <t> x y) -> (SARQ <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [64])))))
+(Rsh64x8 <t> x y) -> (SARQ <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [64])))))
+
+(Rsh32x64 <t> x y) -> (SARL <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [32])))))
+(Rsh32x32 <t> x y) -> (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [32])))))
+(Rsh32x16 <t> x y) -> (SARL <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [32])))))
+(Rsh32x8 <t> x y) -> (SARL <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [32])))))
+
+(Rsh16x64 <t> x y) -> (SARW <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [16])))))
+(Rsh16x32 <t> x y) -> (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [16])))))
+(Rsh16x16 <t> x y) -> (SARW <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [16])))))
+(Rsh16x8 <t> x y) -> (SARW <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [16])))))
+
+(Rsh8x64 <t> x y) -> (SARB <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [8])))))
+(Rsh8x32 <t> x y) -> (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [8])))))
+(Rsh8x16 <t> x y) -> (SARB <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [8])))))
+(Rsh8x8 <t> x y) -> (SARB <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [8])))))
+
+(Less64 x y) -> (SETL (CMPQ x y))
+(Less32 x y) -> (SETL (CMPL x y))
+(Less16 x y) -> (SETL (CMPW x y))
+(Less8 x y) -> (SETL (CMPB x y))
+(Less64U x y) -> (SETB (CMPQ x y))
+(Less32U x y) -> (SETB (CMPL x y))
+(Less16U x y) -> (SETB (CMPW x y))
+(Less8U x y) -> (SETB (CMPB x y))
+// Use SETGF with reversed operands to dodge NaN case
+(Less64F x y) -> (SETGF (UCOMISD y x))
+(Less32F x y) -> (SETGF (UCOMISS y x))
+
+(Leq64 x y) -> (SETLE (CMPQ x y))
+(Leq32 x y) -> (SETLE (CMPL x y))
+(Leq16 x y) -> (SETLE (CMPW x y))
+(Leq8 x y) -> (SETLE (CMPB x y))
+(Leq64U x y) -> (SETBE (CMPQ x y))
+(Leq32U x y) -> (SETBE (CMPL x y))
+(Leq16U x y) -> (SETBE (CMPW x y))
+(Leq8U x y) -> (SETBE (CMPB x y))
+// Use SETGEF with reversed operands to dodge NaN case
+(Leq64F x y) -> (SETGEF (UCOMISD y x))
+(Leq32F x y) -> (SETGEF (UCOMISS y x))
+
+(Greater64 x y) -> (SETG (CMPQ x y))
+(Greater32 x y) -> (SETG (CMPL x y))
+(Greater16 x y) -> (SETG (CMPW x y))
+(Greater8 x y) -> (SETG (CMPB x y))
+(Greater64U x y) -> (SETA (CMPQ x y))
+(Greater32U x y) -> (SETA (CMPL x y))
+(Greater16U x y) -> (SETA (CMPW x y))
+(Greater8U x y) -> (SETA (CMPB x y))
+// Note Go assembler gets UCOMISx operand order wrong, but it is right here
+// Bug is accommodated at generation of assembly language.
+(Greater64F x y) -> (SETGF (UCOMISD x y))
+(Greater32F x y) -> (SETGF (UCOMISS x y))
+
+(Geq64 x y) -> (SETGE (CMPQ x y))
+(Geq32 x y) -> (SETGE (CMPL x y))
+(Geq16 x y) -> (SETGE (CMPW x y))
+(Geq8 x y) -> (SETGE (CMPB x y))
+(Geq64U x y) -> (SETAE (CMPQ x y))
+(Geq32U x y) -> (SETAE (CMPL x y))
+(Geq16U x y) -> (SETAE (CMPW x y))
+(Geq8U x y) -> (SETAE (CMPB x y))
+// Note Go assembler gets UCOMISx operand order wrong, but it is right here
+// Bug is accommodated at generation of assembly language.
+(Geq64F x y) -> (SETGEF (UCOMISD x y))
+(Geq32F x y) -> (SETGEF (UCOMISS x y))
+
+(Eq64 x y) -> (SETEQ (CMPQ x y))
+(Eq32 x y) -> (SETEQ (CMPL x y))
+(Eq16 x y) -> (SETEQ (CMPW x y))
+(Eq8 x y) -> (SETEQ (CMPB x y))
+(EqPtr x y) -> (SETEQ (CMPQ x y))
+(Eq64F x y) -> (SETEQF (UCOMISD x y))
+(Eq32F x y) -> (SETEQF (UCOMISS x y))
+
+(Neq64 x y) -> (SETNE (CMPQ x y))
+(Neq32 x y) -> (SETNE (CMPL x y))
+(Neq16 x y) -> (SETNE (CMPW x y))
+(Neq8 x y) -> (SETNE (CMPB x y))
+(NeqPtr x y) -> (SETNE (CMPQ x y))
+(Neq64F x y) -> (SETNEF (UCOMISD x y))
+(Neq32F x y) -> (SETNEF (UCOMISS x y))
+
+(Load <t> ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem)
+(Load <t> ptr mem) && is32BitInt(t) -> (MOVLload ptr mem)
+(Load <t> ptr mem) && is16BitInt(t) -> (MOVWload ptr mem)
+(Load <t> ptr mem) && (t.IsBoolean() || is8BitInt(t)) -> (MOVBload ptr mem)
+(Load <t> ptr mem) && is32BitFloat(t) -> (MOVSSload ptr mem)
+(Load <t> ptr mem) && is64BitFloat(t) -> (MOVSDload ptr mem)
+
+// These more-specific FP versions of Store pattern should come first.
+(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVSDstore ptr val mem)
+(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVSSstore ptr val mem)
+
+(Store [8] ptr val mem) -> (MOVQstore ptr val mem)
+(Store [4] ptr val mem) -> (MOVLstore ptr val mem)
+(Store [2] ptr val mem) -> (MOVWstore ptr val mem)
+(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
+
+// We want this to stick out so the to/from ptr conversion is obvious
+(Convert <t> x mem) -> (MOVQconvert <t> x mem)
+
+// checks
+(IsNonNil p) -> (SETNE (TESTQ p p))
+(IsInBounds idx len) -> (SETB (CMPQ idx len))
+(IsSliceInBounds idx len) -> (SETBE (CMPQ idx len))
+(NilCheck ptr mem) -> (LoweredNilCheck ptr mem)
+
+(GetG mem) -> (LoweredGetG mem)
+(GetClosurePtr) -> (LoweredGetClosurePtr)
+
+// Small moves
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBload src mem) mem)
+(Move [2] dst src mem) -> (MOVWstore dst (MOVWload src mem) mem)
+(Move [4] dst src mem) -> (MOVLstore dst (MOVLload src mem) mem)
+(Move [8] dst src mem) -> (MOVQstore dst (MOVQload src mem) mem)
+(Move [16] dst src mem) -> (MOVOstore dst (MOVOload src mem) mem)
+(Move [3] dst src mem) ->
+ (MOVBstore [2] dst (MOVBload [2] src mem)
+ (MOVWstore dst (MOVWload src mem) mem))
+(Move [5] dst src mem) ->
+ (MOVBstore [4] dst (MOVBload [4] src mem)
+ (MOVLstore dst (MOVLload src mem) mem))
+(Move [6] dst src mem) ->
+ (MOVWstore [4] dst (MOVWload [4] src mem)
+ (MOVLstore dst (MOVLload src mem) mem))
+(Move [7] dst src mem) ->
+ (MOVLstore [3] dst (MOVLload [3] src mem)
+ (MOVLstore dst (MOVLload src mem) mem))
+(Move [size] dst src mem) && size > 8 && size < 16 ->
+ (MOVQstore [size-8] dst (MOVQload [size-8] src mem)
+ (MOVQstore dst (MOVQload src mem) mem))
+
+// Adjust moves to be a multiple of 16 bytes.
+(Move [size] dst src mem) && size > 16 && size%16 != 0 && size%16 <= 8 ->
+ (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16])
+ (MOVQstore dst (MOVQload src mem) mem))
+(Move [size] dst src mem) && size > 16 && size%16 != 0 && size%16 > 8 ->
+ (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16])
+ (MOVOstore dst (MOVOload src mem) mem))
+
+// Medium copying uses a duff device.
+(Move [size] dst src mem) && size >= 32 && size <= 16*64 && size%16 == 0 ->
+ (DUFFCOPY [14*(64-size/16)] dst src mem)
+// 14 and 64 are magic constants. 14 is the number of bytes to encode:
+// MOVUPS (SI), X0
+// ADDQ $16, SI
+// MOVUPS X0, (DI)
+// ADDQ $16, DI
+// and 64 is the number of such blocks. See src/runtime/duff_amd64.s:duffcopy.
+
+// Large copying uses REP MOVSQ.
+(Move [size] dst src mem) && size > 16*64 && size%8 == 0 ->
+ (REPMOVSQ dst src (MOVQconst [size/8]) mem)
+
+(Not x) -> (XORBconst [1] x)
+
+(OffPtr [off] ptr) -> (ADDQconst [off] ptr)
+
+(Const8 [val]) -> (MOVBconst [val])
+(Const16 [val]) -> (MOVWconst [val])
+(Const32 [val]) -> (MOVLconst [val])
+(Const64 [val]) -> (MOVQconst [val])
+(Const32F [val]) -> (MOVSSconst [val])
+(Const64F [val]) -> (MOVSDconst [val])
+(ConstNil) -> (MOVQconst [0])
+(ConstBool [b]) -> (MOVBconst [b])
+
+(Addr {sym} base) -> (LEAQ {sym} base)
+
+(ITab (Load ptr mem)) -> (MOVQload ptr mem)
+
+// block rewrites
+(If (SETL cmp) yes no) -> (LT cmp yes no)
+(If (SETLE cmp) yes no) -> (LE cmp yes no)
+(If (SETG cmp) yes no) -> (GT cmp yes no)
+(If (SETGE cmp) yes no) -> (GE cmp yes no)
+(If (SETEQ cmp) yes no) -> (EQ cmp yes no)
+(If (SETNE cmp) yes no) -> (NE cmp yes no)
+(If (SETB cmp) yes no) -> (ULT cmp yes no)
+(If (SETBE cmp) yes no) -> (ULE cmp yes no)
+(If (SETA cmp) yes no) -> (UGT cmp yes no)
+(If (SETAE cmp) yes no) -> (UGE cmp yes no)
+
+// Special case for floating point - LF/LEF not generated
+(If (SETGF cmp) yes no) -> (UGT cmp yes no)
+(If (SETGEF cmp) yes no) -> (UGE cmp yes no)
+(If (SETEQF cmp) yes no) -> (EQF cmp yes no)
+(If (SETNEF cmp) yes no) -> (NEF cmp yes no)
+
+(If cond yes no) -> (NE (TESTB cond cond) yes no)
+
+(NE (TESTB (SETL cmp)) yes no) -> (LT cmp yes no)
+(NE (TESTB (SETLE cmp)) yes no) -> (LE cmp yes no)
+(NE (TESTB (SETG cmp)) yes no) -> (GT cmp yes no)
+(NE (TESTB (SETGE cmp)) yes no) -> (GE cmp yes no)
+(NE (TESTB (SETEQ cmp)) yes no) -> (EQ cmp yes no)
+(NE (TESTB (SETNE cmp)) yes no) -> (NE cmp yes no)
+(NE (TESTB (SETB cmp)) yes no) -> (ULT cmp yes no)
+(NE (TESTB (SETBE cmp)) yes no) -> (ULE cmp yes no)
+(NE (TESTB (SETA cmp)) yes no) -> (UGT cmp yes no)
+(NE (TESTB (SETAE cmp)) yes no) -> (UGE cmp yes no)
+
+// Special case for floating point - LF/LEF not generated
+(NE (TESTB (SETGF cmp)) yes no) -> (UGT cmp yes no)
+(NE (TESTB (SETGEF cmp)) yes no) -> (UGE cmp yes no)
+(NE (TESTB (SETEQF cmp)) yes no) -> (EQF cmp yes no)
+(NE (TESTB (SETNEF cmp)) yes no) -> (NEF cmp yes no)
+
+// Disabled because it interferes with the pattern match above and makes worse code.
+// (SETNEF x) -> (ORQ (SETNE <config.Frontend().TypeInt8()> x) (SETNAN <config.Frontend().TypeInt8()> x))
+// (SETEQF x) -> (ANDQ (SETEQ <config.Frontend().TypeInt8()> x) (SETORD <config.Frontend().TypeInt8()> x))
+
+(StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem)
+(ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem)
+(DeferCall [argwid] mem) -> (CALLdefer [argwid] mem)
+(GoCall [argwid] mem) -> (CALLgo [argwid] mem)
+(InterCall [argwid] entry mem) -> (CALLinter [argwid] entry mem)
+
+// Rules below here apply some simple optimizations after lowering.
+// TODO: Should this be a separate pass?
+
+// fold constants into instructions
+(ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x)
+(ADDQ (MOVQconst [c]) x) && is32Bit(c) -> (ADDQconst [c] x)
+(ADDL x (MOVLconst [c])) -> (ADDLconst [c] x)
+(ADDL (MOVLconst [c]) x) -> (ADDLconst [c] x)
+(ADDW x (MOVWconst [c])) -> (ADDWconst [c] x)
+(ADDW (MOVWconst [c]) x) -> (ADDWconst [c] x)
+(ADDB x (MOVBconst [c])) -> (ADDBconst [c] x)
+(ADDB (MOVBconst [c]) x) -> (ADDBconst [c] x)
+
+(SUBQ x (MOVQconst [c])) && is32Bit(c) -> (SUBQconst x [c])
+(SUBQ (MOVQconst [c]) x) && is32Bit(c) -> (NEGQ (SUBQconst <v.Type> x [c]))
+(SUBL x (MOVLconst [c])) -> (SUBLconst x [c])
+(SUBL (MOVLconst [c]) x) -> (NEGL (SUBLconst <v.Type> x [c]))
+(SUBW x (MOVWconst [c])) -> (SUBWconst x [c])
+(SUBW (MOVWconst [c]) x) -> (NEGW (SUBWconst <v.Type> x [c]))
+(SUBB x (MOVBconst [c])) -> (SUBBconst x [c])
+(SUBB (MOVBconst [c]) x) -> (NEGB (SUBBconst <v.Type> x [c]))
+
+(MULQ x (MOVQconst [c])) && is32Bit(c) -> (MULQconst [c] x)
+(MULQ (MOVQconst [c]) x) && is32Bit(c) -> (MULQconst [c] x)
+(MULL x (MOVLconst [c])) -> (MULLconst [c] x)
+(MULL (MOVLconst [c]) x) -> (MULLconst [c] x)
+(MULW x (MOVWconst [c])) -> (MULWconst [c] x)
+(MULW (MOVWconst [c]) x) -> (MULWconst [c] x)
+(MULB x (MOVBconst [c])) -> (MULBconst [c] x)
+(MULB (MOVBconst [c]) x) -> (MULBconst [c] x)
+
+(ANDQ x (MOVQconst [c])) && is32Bit(c) -> (ANDQconst [c] x)
+(ANDQ (MOVQconst [c]) x) && is32Bit(c) -> (ANDQconst [c] x)
+(ANDL x (MOVLconst [c])) -> (ANDLconst [c] x)
+(ANDL (MOVLconst [c]) x) -> (ANDLconst [c] x)
+(ANDW x (MOVLconst [c])) -> (ANDWconst [c] x)
+(ANDW (MOVLconst [c]) x) -> (ANDWconst [c] x)
+(ANDW x (MOVWconst [c])) -> (ANDWconst [c] x)
+(ANDW (MOVWconst [c]) x) -> (ANDWconst [c] x)
+(ANDB x (MOVLconst [c])) -> (ANDBconst [c] x)
+(ANDB (MOVLconst [c]) x) -> (ANDBconst [c] x)
+(ANDB x (MOVBconst [c])) -> (ANDBconst [c] x)
+(ANDB (MOVBconst [c]) x) -> (ANDBconst [c] x)
+
+(ORQ x (MOVQconst [c])) && is32Bit(c) -> (ORQconst [c] x)
+(ORQ (MOVQconst [c]) x) && is32Bit(c) -> (ORQconst [c] x)
+(ORL x (MOVLconst [c])) -> (ORLconst [c] x)
+(ORL (MOVLconst [c]) x) -> (ORLconst [c] x)
+(ORW x (MOVWconst [c])) -> (ORWconst [c] x)
+(ORW (MOVWconst [c]) x) -> (ORWconst [c] x)
+(ORB x (MOVBconst [c])) -> (ORBconst [c] x)
+(ORB (MOVBconst [c]) x) -> (ORBconst [c] x)
+
+(XORQ x (MOVQconst [c])) && is32Bit(c) -> (XORQconst [c] x)
+(XORQ (MOVQconst [c]) x) && is32Bit(c) -> (XORQconst [c] x)
+(XORL x (MOVLconst [c])) -> (XORLconst [c] x)
+(XORL (MOVLconst [c]) x) -> (XORLconst [c] x)
+(XORW x (MOVWconst [c])) -> (XORWconst [c] x)
+(XORW (MOVWconst [c]) x) -> (XORWconst [c] x)
+(XORB x (MOVBconst [c])) -> (XORBconst [c] x)
+(XORB (MOVBconst [c]) x) -> (XORBconst [c] x)
+
+(SHLQ x (MOVQconst [c])) -> (SHLQconst [c&63] x)
+(SHLQ x (MOVLconst [c])) -> (SHLQconst [c&63] x)
+(SHLQ x (MOVWconst [c])) -> (SHLQconst [c&63] x)
+(SHLQ x (MOVBconst [c])) -> (SHLQconst [c&63] x)
+
+(SHLL x (MOVQconst [c])) -> (SHLLconst [c&31] x)
+(SHLL x (MOVLconst [c])) -> (SHLLconst [c&31] x)
+(SHLL x (MOVWconst [c])) -> (SHLLconst [c&31] x)
+(SHLL x (MOVBconst [c])) -> (SHLLconst [c&31] x)
+
+(SHLW x (MOVQconst [c])) -> (SHLWconst [c&31] x)
+(SHLW x (MOVLconst [c])) -> (SHLWconst [c&31] x)
+(SHLW x (MOVWconst [c])) -> (SHLWconst [c&31] x)
+(SHLW x (MOVBconst [c])) -> (SHLWconst [c&31] x)
+
+(SHLB x (MOVQconst [c])) -> (SHLBconst [c&31] x)
+(SHLB x (MOVLconst [c])) -> (SHLBconst [c&31] x)
+(SHLB x (MOVWconst [c])) -> (SHLBconst [c&31] x)
+(SHLB x (MOVBconst [c])) -> (SHLBconst [c&31] x)
+
+(SHRQ x (MOVQconst [c])) -> (SHRQconst [c&63] x)
+(SHRQ x (MOVLconst [c])) -> (SHRQconst [c&63] x)
+(SHRQ x (MOVWconst [c])) -> (SHRQconst [c&63] x)
+(SHRQ x (MOVBconst [c])) -> (SHRQconst [c&63] x)
+
+(SHRL x (MOVQconst [c])) -> (SHRLconst [c&31] x)
+(SHRL x (MOVLconst [c])) -> (SHRLconst [c&31] x)
+(SHRL x (MOVWconst [c])) -> (SHRLconst [c&31] x)
+(SHRL x (MOVBconst [c])) -> (SHRLconst [c&31] x)
+
+(SHRW x (MOVQconst [c])) -> (SHRWconst [c&31] x)
+(SHRW x (MOVLconst [c])) -> (SHRWconst [c&31] x)
+(SHRW x (MOVWconst [c])) -> (SHRWconst [c&31] x)
+(SHRW x (MOVBconst [c])) -> (SHRWconst [c&31] x)
+
+(SHRB x (MOVQconst [c])) -> (SHRBconst [c&31] x)
+(SHRB x (MOVLconst [c])) -> (SHRBconst [c&31] x)
+(SHRB x (MOVWconst [c])) -> (SHRBconst [c&31] x)
+(SHRB x (MOVBconst [c])) -> (SHRBconst [c&31] x)
+
+(SARQ x (MOVQconst [c])) -> (SARQconst [c&63] x)
+(SARQ x (MOVLconst [c])) -> (SARQconst [c&63] x)
+(SARQ x (MOVWconst [c])) -> (SARQconst [c&63] x)
+(SARQ x (MOVBconst [c])) -> (SARQconst [c&63] x)
+
+(SARL x (MOVQconst [c])) -> (SARLconst [c&31] x)
+(SARL x (MOVLconst [c])) -> (SARLconst [c&31] x)
+(SARL x (MOVWconst [c])) -> (SARLconst [c&31] x)
+(SARL x (MOVBconst [c])) -> (SARLconst [c&31] x)
+
+(SARW x (MOVQconst [c])) -> (SARWconst [c&31] x)
+(SARW x (MOVLconst [c])) -> (SARWconst [c&31] x)
+(SARW x (MOVWconst [c])) -> (SARWconst [c&31] x)
+(SARW x (MOVBconst [c])) -> (SARWconst [c&31] x)
+
+(SARB x (MOVQconst [c])) -> (SARBconst [c&31] x)
+(SARB x (MOVLconst [c])) -> (SARBconst [c&31] x)
+(SARB x (MOVWconst [c])) -> (SARBconst [c&31] x)
+(SARB x (MOVBconst [c])) -> (SARBconst [c&31] x)
+
+// Note: the word and byte shifts keep the low 5 bits (not the low 4 or 3 bits)
+// because the x86 instructions are defined to use all 5 bits of the shift even
+// for the small shifts. I don't think we'll ever generate a weird shift (e.g.
+// (SHLW x (MOVWconst [24])), but just in case.
+
+(CMPQ x (MOVQconst [c])) && is32Bit(c) -> (CMPQconst x [c])
+(CMPQ (MOVQconst [c]) x) && is32Bit(c) -> (InvertFlags (CMPQconst x [c]))
+(CMPL x (MOVLconst [c])) -> (CMPLconst x [c])
+(CMPL (MOVLconst [c]) x) -> (InvertFlags (CMPLconst x [c]))
+(CMPW x (MOVWconst [c])) -> (CMPWconst x [c])
+(CMPW (MOVWconst [c]) x) -> (InvertFlags (CMPWconst x [c]))
+(CMPB x (MOVBconst [c])) -> (CMPBconst x [c])
+(CMPB (MOVBconst [c]) x) -> (InvertFlags (CMPBconst x [c]))
+
+// strength reduction
+(MULQconst [-1] x) -> (NEGQ x)
+(MULQconst [0] _) -> (MOVQconst [0])
+(MULQconst [1] x) -> x
+(MULQconst [3] x) -> (LEAQ2 x x)
+(MULQconst [5] x) -> (LEAQ4 x x)
+(MULQconst [9] x) -> (LEAQ8 x x)
+(MULQconst [c] x) && isPowerOfTwo(c) -> (SHLQconst [log2(c)] x)
+
+// combine add/shift into LEAQ
+(ADDQ x (SHLQconst [3] y)) -> (LEAQ8 x y)
+(ADDQ x (SHLQconst [2] y)) -> (LEAQ4 x y)
+(ADDQ x (SHLQconst [1] y)) -> (LEAQ2 x y)
+(ADDQ x (ADDQ y y)) -> (LEAQ2 x y)
+(ADDQ x (ADDQ x y)) -> (LEAQ2 y x)
+(ADDQ x (ADDQ y x)) -> (LEAQ2 y x)
+
+// combine ADDQ/ADDQconst into LEAQ1
+(ADDQconst [c] (ADDQ x y)) -> (LEAQ1 [c] x y)
+(ADDQ (ADDQconst [c] x) y) -> (LEAQ1 [c] x y)
+(ADDQ x (ADDQconst [c] y)) -> (LEAQ1 [c] x y)
+
+// fold ADDQ into LEAQ
+(ADDQconst [c] (LEAQ [d] {s} x)) -> (LEAQ [c+d] {s} x)
+(LEAQ [c] {s} (ADDQconst [d] x)) -> (LEAQ [c+d] {s} x)
+(LEAQ [c] {s} (ADDQ x y)) && x.Op != OpSB && y.Op != OpSB -> (LEAQ1 [c] {s} x y)
+(ADDQ x (LEAQ [c] {s} y)) && x.Op != OpSB && y.Op != OpSB -> (LEAQ1 [c] {s} x y)
+(ADDQ (LEAQ [c] {s} x) y) && x.Op != OpSB && y.Op != OpSB -> (LEAQ1 [c] {s} x y)
+
+// fold ADDQconst into leaqX
+(ADDQconst [c] (LEAQ1 [d] {s} x y)) -> (LEAQ1 [c+d] {s} x y)
+(ADDQconst [c] (LEAQ2 [d] {s} x y)) -> (LEAQ2 [c+d] {s} x y)
+(ADDQconst [c] (LEAQ4 [d] {s} x y)) -> (LEAQ4 [c+d] {s} x y)
+(ADDQconst [c] (LEAQ8 [d] {s} x y)) -> (LEAQ8 [c+d] {s} x y)
+(LEAQ1 [c] {s} (ADDQconst [d] x) y) && x.Op != OpSB -> (LEAQ1 [c+d] {s} x y)
+(LEAQ1 [c] {s} x (ADDQconst [d] y)) && y.Op != OpSB -> (LEAQ1 [c+d] {s} x y)
+(LEAQ2 [c] {s} (ADDQconst [d] x) y) && x.Op != OpSB -> (LEAQ2 [c+d] {s} x y)
+(LEAQ2 [c] {s} x (ADDQconst [d] y)) && y.Op != OpSB -> (LEAQ2 [c+2*d] {s} x y)
+(LEAQ4 [c] {s} (ADDQconst [d] x) y) && x.Op != OpSB -> (LEAQ4 [c+d] {s} x y)
+(LEAQ4 [c] {s} x (ADDQconst [d] y)) && y.Op != OpSB -> (LEAQ4 [c+4*d] {s} x y)
+(LEAQ8 [c] {s} (ADDQconst [d] x) y) && x.Op != OpSB -> (LEAQ8 [c+d] {s} x y)
+(LEAQ8 [c] {s} x (ADDQconst [d] y)) && y.Op != OpSB -> (LEAQ8 [c+8*d] {s} x y)
+
+// reverse ordering of compare instruction
+(SETL (InvertFlags x)) -> (SETG x)
+(SETG (InvertFlags x)) -> (SETL x)
+(SETB (InvertFlags x)) -> (SETA x)
+(SETA (InvertFlags x)) -> (SETB x)
+(SETLE (InvertFlags x)) -> (SETGE x)
+(SETGE (InvertFlags x)) -> (SETLE x)
+(SETBE (InvertFlags x)) -> (SETAE x)
+(SETAE (InvertFlags x)) -> (SETBE x)
+(SETEQ (InvertFlags x)) -> (SETEQ x)
+(SETNE (InvertFlags x)) -> (SETNE x)
+
+// sign extended loads
+// Note: The combined instruction must end up in the same block
+// as the original load. If not, we end up making a value with
+// memory type live in two different blocks, which can lead to
+// multiple memory values alive simultaneously.
+(MOVBQSX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQSXload <v.Type> [off] {sym} ptr mem)
+(MOVBQZX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQZXload <v.Type> [off] {sym} ptr mem)
+(MOVWQSX (MOVWload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVWQSXload <v.Type> [off] {sym} ptr mem)
+(MOVWQZX (MOVWload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVWQZXload <v.Type> [off] {sym} ptr mem)
+(MOVLQSX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQSXload <v.Type> [off] {sym} ptr mem)
+(MOVLQZX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQZXload <v.Type> [off] {sym} ptr mem)
+
+// replace load from same location as preceding store with copy
+(MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
+(MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
+(MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
+(MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
+
+// Fold extensions and ANDs together.
+(MOVBQZX (ANDBconst [c] x)) -> (ANDQconst [c & 0xff] x)
+(MOVWQZX (ANDWconst [c] x)) -> (ANDQconst [c & 0xffff] x)
+(MOVLQZX (ANDLconst [c] x)) -> (ANDQconst [c & 0xffffffff] x)
+(MOVBQSX (ANDBconst [c] x)) && c & 0x80 == 0 -> (ANDQconst [c & 0x7f] x)
+(MOVWQSX (ANDWconst [c] x)) && c & 0x8000 == 0 -> (ANDQconst [c & 0x7fff] x)
+(MOVLQSX (ANDLconst [c] x)) && c & 0x80000000 == 0 -> (ANDQconst [c & 0x7fffffff] x)
+
+// Don't extend before storing
+(MOVLstore [off] {sym} ptr (MOVLQSX x) mem) -> (MOVLstore [off] {sym} ptr x mem)
+(MOVWstore [off] {sym} ptr (MOVWQSX x) mem) -> (MOVWstore [off] {sym} ptr x mem)
+(MOVBstore [off] {sym} ptr (MOVBQSX x) mem) -> (MOVBstore [off] {sym} ptr x mem)
+(MOVLstore [off] {sym} ptr (MOVLQZX x) mem) -> (MOVLstore [off] {sym} ptr x mem)
+(MOVWstore [off] {sym} ptr (MOVWQZX x) mem) -> (MOVWstore [off] {sym} ptr x mem)
+(MOVBstore [off] {sym} ptr (MOVBQZX x) mem) -> (MOVBstore [off] {sym} ptr x mem)
+
+// fold constants into memory operations
+// Note that this is not always a good idea because if not all the uses of
+// the ADDQconst get eliminated, we still have to compute the ADDQconst and we now
+// have potentially two live values (ptr and (ADDQconst [off] ptr)) instead of one.
+// Nevertheless, let's do it!
+(MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] {sym} ptr mem)
+(MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVLload [addOff(off1, off2)] {sym} ptr mem)
+(MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVWload [addOff(off1, off2)] {sym} ptr mem)
+(MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVBload [addOff(off1, off2)] {sym} ptr mem)
+(MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVSSload [addOff(off1, off2)] {sym} ptr mem)
+(MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVSDload [addOff(off1, off2)] {sym} ptr mem)
+(MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem) -> (MOVOload [addOff(off1, off2)] {sym} ptr mem)
+
+(MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVLstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVWstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVBstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVSSstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVSDstore [addOff(off1, off2)] {sym} ptr val mem)
+(MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem) -> (MOVOstore [addOff(off1, off2)] {sym} ptr val mem)
+
+// Fold constants into stores.
+(MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) && validValAndOff(c,off) ->
+ (MOVQstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
+(MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) && validOff(off) ->
+ (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
+(MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) && validOff(off) ->
+ (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
+(MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) && validOff(off) ->
+ (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
+
+// Fold address offsets into constant stores.
+(MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && ValAndOff(sc).canAdd(off) ->
+ (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+(MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && ValAndOff(sc).canAdd(off) ->
+ (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+(MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && ValAndOff(sc).canAdd(off) ->
+ (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+(MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && ValAndOff(sc).canAdd(off) ->
+ (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+
+// We need to fold LEAQ into the MOVx ops so that the live variable analysis knows
+// what variables are being read/written by the ops.
+(MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+(MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) ->
+ (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+
+(MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVLstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVLstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVWstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVWstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVBstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVBstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+(MOVOstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVOstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+
+(MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) ->
+ (MOVQstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+(MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) ->
+ (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+(MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) ->
+ (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+(MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) ->
+ (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+
+// generating indexed loads and stores
+(MOVBload [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVBloadidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVWload [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVWloadidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVLload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVLloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVQload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVQloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVSSload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVSSloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVSDload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVSDloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+
+(MOVBstore [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVBstoreidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+(MOVWstore [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVWstoreidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+(MOVLstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVLstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+(MOVQstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVQstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+(MOVSSstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVSSstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+(MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) ->
+ (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+
+(MOVBload [off] {sym} (ADDQ ptr idx) mem) && ptr.Op != OpSB -> (MOVBloadidx1 [off] {sym} ptr idx mem)
+(MOVBstore [off] {sym} (ADDQ ptr idx) val mem) && ptr.Op != OpSB -> (MOVBstoreidx1 [off] {sym} ptr idx val mem)
+
+(MOVBstoreconst [x] {sym1} (LEAQ1 [off] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVBstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVWstoreconst [x] {sym1} (LEAQ2 [off] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVWstoreconstidx2 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVLstoreconst [x] {sym1} (LEAQ4 [off] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVLstoreconstidx4 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVQstoreconst [x] {sym1} (LEAQ8 [off] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) ->
+ (MOVQstoreconstidx8 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+(MOVBstoreconst [x] {sym} (ADDQ ptr idx) mem) -> (MOVBstoreconstidx1 [x] {sym} ptr idx mem)
+
+// combine ADDQ into indexed loads and stores
+(MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVBloadidx1 [c+d] {sym} ptr idx mem)
+(MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVWloadidx2 [c+d] {sym} ptr idx mem)
+(MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVLloadidx4 [c+d] {sym} ptr idx mem)
+(MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVQloadidx8 [c+d] {sym} ptr idx mem)
+(MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
+(MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) -> (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
+
+(MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
+(MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVWstoreidx2 [c+d] {sym} ptr idx val mem)
+(MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
+(MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
+(MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
+(MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) -> (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
+
+(MOVBloadidx1 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVBloadidx1 [c+d] {sym} ptr idx mem)
+(MOVWloadidx2 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVWloadidx2 [c+2*d] {sym} ptr idx mem)
+(MOVLloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVLloadidx4 [c+4*d] {sym} ptr idx mem)
+(MOVQloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVQloadidx8 [c+8*d] {sym} ptr idx mem)
+(MOVSSloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVSSloadidx4 [c+4*d] {sym} ptr idx mem)
+(MOVSDloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem) -> (MOVSDloadidx8 [c+8*d] {sym} ptr idx mem)
+
+(MOVBstoreidx1 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
+(MOVWstoreidx2 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVWstoreidx2 [c+2*d] {sym} ptr idx val mem)
+(MOVLstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVLstoreidx4 [c+4*d] {sym} ptr idx val mem)
+(MOVQstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVQstoreidx8 [c+8*d] {sym} ptr idx val mem)
+(MOVSSstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVSSstoreidx4 [c+4*d] {sym} ptr idx val mem)
+(MOVSDstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem) -> (MOVSDstoreidx8 [c+8*d] {sym} ptr idx val mem)
+
+(MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem) ->
+ (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+(MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem) ->
+ (MOVWstoreconstidx2 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+(MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem) ->
+ (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+(MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem) ->
+ (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+
+(MOVBstoreconstidx1 [x] {sym} ptr (ADDQconst [c] idx) mem) ->
+ (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+(MOVWstoreconstidx2 [x] {sym} ptr (ADDQconst [c] idx) mem) ->
+ (MOVWstoreconstidx2 [ValAndOff(x).add(2*c)] {sym} ptr idx mem)
+(MOVLstoreconstidx4 [x] {sym} ptr (ADDQconst [c] idx) mem) ->
+ (MOVLstoreconstidx4 [ValAndOff(x).add(4*c)] {sym} ptr idx mem)
+(MOVQstoreconstidx8 [x] {sym} ptr (ADDQconst [c] idx) mem) ->
+ (MOVQstoreconstidx8 [ValAndOff(x).add(8*c)] {sym} ptr idx mem)
+
+// fold LEAQs together
+(LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x)) && canMergeSym(sym1, sym2) ->
+ (LEAQ [addOff(off1,off2)] {mergeSym(sym1,sym2)} x)
+
+// LEAQ into LEAQ1
+(LEAQ1 [off1] {sym1} (LEAQ [off2] {sym2} x) y) && canMergeSym(sym1, sym2) && x.Op != OpSB ->
+ (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+(LEAQ1 [off1] {sym1} x (LEAQ [off2] {sym2} y)) && canMergeSym(sym1, sym2) && y.Op != OpSB ->
+ (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+
+// LEAQ1 into LEAQ
+(LEAQ [off1] {sym1} (LEAQ1 [off2] {sym2} x y)) && canMergeSym(sym1, sym2) ->
+ (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+
+// LEAQ into LEAQ[248]
+(LEAQ2 [off1] {sym1} (LEAQ [off2] {sym2} x) y) && canMergeSym(sym1, sym2) && x.Op != OpSB ->
+ (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+(LEAQ4 [off1] {sym1} (LEAQ [off2] {sym2} x) y) && canMergeSym(sym1, sym2) && x.Op != OpSB ->
+ (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+(LEAQ8 [off1] {sym1} (LEAQ [off2] {sym2} x) y) && canMergeSym(sym1, sym2) && x.Op != OpSB ->
+ (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+
+// LEAQ[248] into LEAQ
+(LEAQ [off1] {sym1} (LEAQ2 [off2] {sym2} x y)) && canMergeSym(sym1, sym2) ->
+ (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+(LEAQ [off1] {sym1} (LEAQ4 [off2] {sym2} x y)) && canMergeSym(sym1, sym2) ->
+ (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+(LEAQ [off1] {sym1} (LEAQ8 [off2] {sym2} x y)) && canMergeSym(sym1, sym2) ->
+ (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+
+// lower Zero instructions with word sizes
+(Zero [0] _ mem) -> mem
+(Zero [1] destptr mem) -> (MOVBstoreconst [0] destptr mem)
+(Zero [2] destptr mem) -> (MOVWstoreconst [0] destptr mem)
+(Zero [4] destptr mem) -> (MOVLstoreconst [0] destptr mem)
+(Zero [8] destptr mem) -> (MOVQstoreconst [0] destptr mem)
+
+(Zero [3] destptr mem) ->
+ (MOVBstoreconst [makeValAndOff(0,2)] destptr
+ (MOVWstoreconst [0] destptr mem))
+(Zero [5] destptr mem) ->
+ (MOVBstoreconst [makeValAndOff(0,4)] destptr
+ (MOVLstoreconst [0] destptr mem))
+(Zero [6] destptr mem) ->
+ (MOVWstoreconst [makeValAndOff(0,4)] destptr
+ (MOVLstoreconst [0] destptr mem))
+(Zero [7] destptr mem) ->
+ (MOVLstoreconst [makeValAndOff(0,3)] destptr
+ (MOVLstoreconst [0] destptr mem))
+
+// Strip off any fractional word zeroing.
+(Zero [size] destptr mem) && size%8 != 0 && size > 8 ->
+ (Zero [size-size%8] (ADDQconst destptr [size%8])
+ (MOVQstoreconst [0] destptr mem))
+
+// Zero small numbers of words directly.
+(Zero [16] destptr mem) ->
+ (MOVQstoreconst [makeValAndOff(0,8)] destptr
+ (MOVQstoreconst [0] destptr mem))
+(Zero [24] destptr mem) ->
+ (MOVQstoreconst [makeValAndOff(0,16)] destptr
+ (MOVQstoreconst [makeValAndOff(0,8)] destptr
+ (MOVQstoreconst [0] destptr mem)))
+(Zero [32] destptr mem) ->
+ (MOVQstoreconst [makeValAndOff(0,24)] destptr
+ (MOVQstoreconst [makeValAndOff(0,16)] destptr
+ (MOVQstoreconst [makeValAndOff(0,8)] destptr
+ (MOVQstoreconst [0] destptr mem))))
+
+// Medium zeroing uses a duff device.
+(Zero [size] destptr mem) && size <= 1024 && size%8 == 0 && size%16 != 0 ->
+ (Zero [size-8] (ADDQconst [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
+(Zero [size] destptr mem) && size <= 1024 && size%16 == 0 ->
+ (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVOconst [0]) mem)
+
+// Large zeroing uses REP STOSQ.
+(Zero [size] destptr mem) && size > 1024 && size%8 == 0 ->
+ (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem)
+
+// Absorb InvertFlags into branches.
+(LT (InvertFlags cmp) yes no) -> (GT cmp yes no)
+(GT (InvertFlags cmp) yes no) -> (LT cmp yes no)
+(LE (InvertFlags cmp) yes no) -> (GE cmp yes no)
+(GE (InvertFlags cmp) yes no) -> (LE cmp yes no)
+(ULT (InvertFlags cmp) yes no) -> (UGT cmp yes no)
+(UGT (InvertFlags cmp) yes no) -> (ULT cmp yes no)
+(ULE (InvertFlags cmp) yes no) -> (UGE cmp yes no)
+(UGE (InvertFlags cmp) yes no) -> (ULE cmp yes no)
+(EQ (InvertFlags cmp) yes no) -> (EQ cmp yes no)
+(NE (InvertFlags cmp) yes no) -> (NE cmp yes no)
+
+// Constant comparisons.
+(CMPQconst (MOVQconst [x]) [y]) && x==y -> (FlagEQ)
+(CMPQconst (MOVQconst [x]) [y]) && x<y && uint64(x)<uint64(y) -> (FlagLT_ULT)
+(CMPQconst (MOVQconst [x]) [y]) && x<y && uint64(x)>uint64(y) -> (FlagLT_UGT)
+(CMPQconst (MOVQconst [x]) [y]) && x>y && uint64(x)<uint64(y) -> (FlagGT_ULT)
+(CMPQconst (MOVQconst [x]) [y]) && x>y && uint64(x)>uint64(y) -> (FlagGT_UGT)
+(CMPLconst (MOVLconst [x]) [y]) && int32(x)==int32(y) -> (FlagEQ)
+(CMPLconst (MOVLconst [x]) [y]) && int32(x)<int32(y) && uint32(x)<uint32(y) -> (FlagLT_ULT)
+(CMPLconst (MOVLconst [x]) [y]) && int32(x)<int32(y) && uint32(x)>uint32(y) -> (FlagLT_UGT)
+(CMPLconst (MOVLconst [x]) [y]) && int32(x)>int32(y) && uint32(x)<uint32(y) -> (FlagGT_ULT)
+(CMPLconst (MOVLconst [x]) [y]) && int32(x)>int32(y) && uint32(x)>uint32(y) -> (FlagGT_UGT)
+(CMPWconst (MOVWconst [x]) [y]) && int16(x)==int16(y) -> (FlagEQ)
+(CMPWconst (MOVWconst [x]) [y]) && int16(x)<int16(y) && uint16(x)<uint16(y) -> (FlagLT_ULT)
+(CMPWconst (MOVWconst [x]) [y]) && int16(x)<int16(y) && uint16(x)>uint16(y) -> (FlagLT_UGT)
+(CMPWconst (MOVWconst [x]) [y]) && int16(x)>int16(y) && uint16(x)<uint16(y) -> (FlagGT_ULT)
+(CMPWconst (MOVWconst [x]) [y]) && int16(x)>int16(y) && uint16(x)>uint16(y) -> (FlagGT_UGT)
+(CMPBconst (MOVBconst [x]) [y]) && int8(x)==int8(y) -> (FlagEQ)
+(CMPBconst (MOVBconst [x]) [y]) && int8(x)<int8(y) && uint8(x)<uint8(y) -> (FlagLT_ULT)
+(CMPBconst (MOVBconst [x]) [y]) && int8(x)<int8(y) && uint8(x)>uint8(y) -> (FlagLT_UGT)
+(CMPBconst (MOVBconst [x]) [y]) && int8(x)>int8(y) && uint8(x)<uint8(y) -> (FlagGT_ULT)
+(CMPBconst (MOVBconst [x]) [y]) && int8(x)>int8(y) && uint8(x)>uint8(y) -> (FlagGT_UGT)
+
+// Other known comparisons.
+(CMPQconst (ANDQconst _ [m]) [n]) && m+1==n && isPowerOfTwo(n) -> (FlagLT_ULT)
+(CMPLconst (ANDLconst _ [m]) [n]) && int32(m)+1==int32(n) && isPowerOfTwo(int64(int32(n))) -> (FlagLT_ULT)
+(CMPWconst (ANDWconst _ [m]) [n]) && int16(m)+1==int16(n) && isPowerOfTwo(int64(int16(n))) -> (FlagLT_ULT)
+(CMPBconst (ANDBconst _ [m]) [n]) && int8(m)+1==int8(n) && isPowerOfTwo(int64(int8(n))) -> (FlagLT_ULT)
+// TODO: DIVxU also.
+
+// Absorb flag constants into SBB ops.
+(SBBQcarrymask (FlagEQ)) -> (MOVQconst [0])
+(SBBQcarrymask (FlagLT_ULT)) -> (MOVQconst [-1])
+(SBBQcarrymask (FlagLT_UGT)) -> (MOVQconst [0])
+(SBBQcarrymask (FlagGT_ULT)) -> (MOVQconst [-1])
+(SBBQcarrymask (FlagGT_UGT)) -> (MOVQconst [0])
+(SBBLcarrymask (FlagEQ)) -> (MOVLconst [0])
+(SBBLcarrymask (FlagLT_ULT)) -> (MOVLconst [-1])
+(SBBLcarrymask (FlagLT_UGT)) -> (MOVLconst [0])
+(SBBLcarrymask (FlagGT_ULT)) -> (MOVLconst [-1])
+(SBBLcarrymask (FlagGT_UGT)) -> (MOVLconst [0])
+
+// Absorb flag constants into branches.
+(EQ (FlagEQ) yes no) -> (First nil yes no)
+(EQ (FlagLT_ULT) yes no) -> (First nil no yes)
+(EQ (FlagLT_UGT) yes no) -> (First nil no yes)
+(EQ (FlagGT_ULT) yes no) -> (First nil no yes)
+(EQ (FlagGT_UGT) yes no) -> (First nil no yes)
+
+(NE (FlagEQ) yes no) -> (First nil no yes)
+(NE (FlagLT_ULT) yes no) -> (First nil yes no)
+(NE (FlagLT_UGT) yes no) -> (First nil yes no)
+(NE (FlagGT_ULT) yes no) -> (First nil yes no)
+(NE (FlagGT_UGT) yes no) -> (First nil yes no)
+
+(LT (FlagEQ) yes no) -> (First nil no yes)
+(LT (FlagLT_ULT) yes no) -> (First nil yes no)
+(LT (FlagLT_UGT) yes no) -> (First nil yes no)
+(LT (FlagGT_ULT) yes no) -> (First nil no yes)
+(LT (FlagGT_UGT) yes no) -> (First nil no yes)
+
+(LE (FlagEQ) yes no) -> (First nil yes no)
+(LE (FlagLT_ULT) yes no) -> (First nil yes no)
+(LE (FlagLT_UGT) yes no) -> (First nil yes no)
+(LE (FlagGT_ULT) yes no) -> (First nil no yes)
+(LE (FlagGT_UGT) yes no) -> (First nil no yes)
+
+(GT (FlagEQ) yes no) -> (First nil no yes)
+(GT (FlagLT_ULT) yes no) -> (First nil no yes)
+(GT (FlagLT_UGT) yes no) -> (First nil no yes)
+(GT (FlagGT_ULT) yes no) -> (First nil yes no)
+(GT (FlagGT_UGT) yes no) -> (First nil yes no)
+
+(GE (FlagEQ) yes no) -> (First nil yes no)
+(GE (FlagLT_ULT) yes no) -> (First nil no yes)
+(GE (FlagLT_UGT) yes no) -> (First nil no yes)
+(GE (FlagGT_ULT) yes no) -> (First nil yes no)
+(GE (FlagGT_UGT) yes no) -> (First nil yes no)
+
+(ULT (FlagEQ) yes no) -> (First nil no yes)
+(ULT (FlagLT_ULT) yes no) -> (First nil yes no)
+(ULT (FlagLT_UGT) yes no) -> (First nil no yes)
+(ULT (FlagGT_ULT) yes no) -> (First nil yes no)
+(ULT (FlagGT_UGT) yes no) -> (First nil no yes)
+
+(ULE (FlagEQ) yes no) -> (First nil yes no)
+(ULE (FlagLT_ULT) yes no) -> (First nil yes no)
+(ULE (FlagLT_UGT) yes no) -> (First nil no yes)
+(ULE (FlagGT_ULT) yes no) -> (First nil yes no)
+(ULE (FlagGT_UGT) yes no) -> (First nil no yes)
+
+(UGT (FlagEQ) yes no) -> (First nil no yes)
+(UGT (FlagLT_ULT) yes no) -> (First nil no yes)
+(UGT (FlagLT_UGT) yes no) -> (First nil yes no)
+(UGT (FlagGT_ULT) yes no) -> (First nil no yes)
+(UGT (FlagGT_UGT) yes no) -> (First nil yes no)
+
+(UGE (FlagEQ) yes no) -> (First nil yes no)
+(UGE (FlagLT_ULT) yes no) -> (First nil no yes)
+(UGE (FlagLT_UGT) yes no) -> (First nil yes no)
+(UGE (FlagGT_ULT) yes no) -> (First nil no yes)
+(UGE (FlagGT_UGT) yes no) -> (First nil yes no)
+
+// Absorb flag constants into SETxx ops.
+(SETEQ (FlagEQ)) -> (MOVBconst [1])
+(SETEQ (FlagLT_ULT)) -> (MOVBconst [0])
+(SETEQ (FlagLT_UGT)) -> (MOVBconst [0])
+(SETEQ (FlagGT_ULT)) -> (MOVBconst [0])
+(SETEQ (FlagGT_UGT)) -> (MOVBconst [0])
+
+(SETNE (FlagEQ)) -> (MOVBconst [0])
+(SETNE (FlagLT_ULT)) -> (MOVBconst [1])
+(SETNE (FlagLT_UGT)) -> (MOVBconst [1])
+(SETNE (FlagGT_ULT)) -> (MOVBconst [1])
+(SETNE (FlagGT_UGT)) -> (MOVBconst [1])
+
+(SETL (FlagEQ)) -> (MOVBconst [0])
+(SETL (FlagLT_ULT)) -> (MOVBconst [1])
+(SETL (FlagLT_UGT)) -> (MOVBconst [1])
+(SETL (FlagGT_ULT)) -> (MOVBconst [0])
+(SETL (FlagGT_UGT)) -> (MOVBconst [0])
+
+(SETLE (FlagEQ)) -> (MOVBconst [1])
+(SETLE (FlagLT_ULT)) -> (MOVBconst [1])
+(SETLE (FlagLT_UGT)) -> (MOVBconst [1])
+(SETLE (FlagGT_ULT)) -> (MOVBconst [0])
+(SETLE (FlagGT_UGT)) -> (MOVBconst [0])
+
+(SETG (FlagEQ)) -> (MOVBconst [0])
+(SETG (FlagLT_ULT)) -> (MOVBconst [0])
+(SETG (FlagLT_UGT)) -> (MOVBconst [0])
+(SETG (FlagGT_ULT)) -> (MOVBconst [1])
+(SETG (FlagGT_UGT)) -> (MOVBconst [1])
+
+(SETGE (FlagEQ)) -> (MOVBconst [1])
+(SETGE (FlagLT_ULT)) -> (MOVBconst [0])
+(SETGE (FlagLT_UGT)) -> (MOVBconst [0])
+(SETGE (FlagGT_ULT)) -> (MOVBconst [1])
+(SETGE (FlagGT_UGT)) -> (MOVBconst [1])
+
+(SETB (FlagEQ)) -> (MOVBconst [0])
+(SETB (FlagLT_ULT)) -> (MOVBconst [1])
+(SETB (FlagLT_UGT)) -> (MOVBconst [0])
+(SETB (FlagGT_ULT)) -> (MOVBconst [1])
+(SETB (FlagGT_UGT)) -> (MOVBconst [0])
+
+(SETBE (FlagEQ)) -> (MOVBconst [1])
+(SETBE (FlagLT_ULT)) -> (MOVBconst [1])
+(SETBE (FlagLT_UGT)) -> (MOVBconst [0])
+(SETBE (FlagGT_ULT)) -> (MOVBconst [1])
+(SETBE (FlagGT_UGT)) -> (MOVBconst [0])
+
+(SETA (FlagEQ)) -> (MOVBconst [0])
+(SETA (FlagLT_ULT)) -> (MOVBconst [0])
+(SETA (FlagLT_UGT)) -> (MOVBconst [1])
+(SETA (FlagGT_ULT)) -> (MOVBconst [0])
+(SETA (FlagGT_UGT)) -> (MOVBconst [1])
+
+(SETAE (FlagEQ)) -> (MOVBconst [1])
+(SETAE (FlagLT_ULT)) -> (MOVBconst [0])
+(SETAE (FlagLT_UGT)) -> (MOVBconst [1])
+(SETAE (FlagGT_ULT)) -> (MOVBconst [0])
+(SETAE (FlagGT_UGT)) -> (MOVBconst [1])
+
+// Remove redundant *const ops
+(ADDQconst [0] x) -> x
+(ADDLconst [c] x) && int32(c)==0 -> x
+(ADDWconst [c] x) && int16(c)==0 -> x
+(ADDBconst [c] x) && int8(c)==0 -> x
+(SUBQconst [0] x) -> x
+(SUBLconst [c] x) && int32(c) == 0 -> x
+(SUBWconst [c] x) && int16(c) == 0 -> x
+(SUBBconst [c] x) && int8(c) == 0 -> x
+(ANDQconst [0] _) -> (MOVQconst [0])
+(ANDLconst [c] _) && int32(c)==0 -> (MOVLconst [0])
+(ANDWconst [c] _) && int16(c)==0 -> (MOVWconst [0])
+(ANDBconst [c] _) && int8(c)==0 -> (MOVBconst [0])
+(ANDQconst [-1] x) -> x
+(ANDLconst [c] x) && int32(c)==-1 -> x
+(ANDWconst [c] x) && int16(c)==-1 -> x
+(ANDBconst [c] x) && int8(c)==-1 -> x
+(ORQconst [0] x) -> x
+(ORLconst [c] x) && int32(c)==0 -> x
+(ORWconst [c] x) && int16(c)==0 -> x
+(ORBconst [c] x) && int8(c)==0 -> x
+(ORQconst [-1] _) -> (MOVQconst [-1])
+(ORLconst [c] _) && int32(c)==-1 -> (MOVLconst [-1])
+(ORWconst [c] _) && int16(c)==-1 -> (MOVWconst [-1])
+(ORBconst [c] _) && int8(c)==-1 -> (MOVBconst [-1])
+(XORQconst [0] x) -> x
+(XORLconst [c] x) && int32(c)==0 -> x
+(XORWconst [c] x) && int16(c)==0 -> x
+(XORBconst [c] x) && int8(c)==0 -> x
+
+// generic constant folding
+// TODO: more of this
+(ADDQconst [c] (MOVQconst [d])) -> (MOVQconst [c+d])
+(ADDLconst [c] (MOVLconst [d])) -> (MOVLconst [c+d])
+(ADDWconst [c] (MOVWconst [d])) -> (MOVWconst [c+d])
+(ADDBconst [c] (MOVBconst [d])) -> (MOVBconst [c+d])
+(ADDQconst [c] (ADDQconst [d] x)) -> (ADDQconst [c+d] x)
+(ADDLconst [c] (ADDLconst [d] x)) -> (ADDLconst [c+d] x)
+(ADDWconst [c] (ADDWconst [d] x)) -> (ADDWconst [c+d] x)
+(ADDBconst [c] (ADDBconst [d] x)) -> (ADDBconst [c+d] x)
+(SUBQconst [c] (MOVQconst [d])) -> (MOVQconst [d-c])
+(SUBLconst [c] (MOVLconst [d])) -> (MOVLconst [d-c])
+(SUBWconst [c] (MOVWconst [d])) -> (MOVWconst [d-c])
+(SUBBconst [c] (MOVBconst [d])) -> (MOVBconst [d-c])
+(SUBQconst [c] (SUBQconst [d] x)) -> (ADDQconst [-c-d] x)
+(SUBLconst [c] (SUBLconst [d] x)) -> (ADDLconst [-c-d] x)
+(SUBWconst [c] (SUBWconst [d] x)) -> (ADDWconst [-c-d] x)
+(SUBBconst [c] (SUBBconst [d] x)) -> (ADDBconst [-c-d] x)
+(SARQconst [c] (MOVQconst [d])) -> (MOVQconst [d>>uint64(c)])
+(SARLconst [c] (MOVQconst [d])) -> (MOVQconst [d>>uint64(c)])
+(SARWconst [c] (MOVQconst [d])) -> (MOVQconst [d>>uint64(c)])
+(SARBconst [c] (MOVQconst [d])) -> (MOVQconst [d>>uint64(c)])
+(NEGQ (MOVQconst [c])) -> (MOVQconst [-c])
+(NEGL (MOVLconst [c])) -> (MOVLconst [-c])
+(NEGW (MOVWconst [c])) -> (MOVWconst [-c])
+(NEGB (MOVBconst [c])) -> (MOVBconst [-c])
+(MULQconst [c] (MOVQconst [d])) -> (MOVQconst [c*d])
+(MULLconst [c] (MOVLconst [d])) -> (MOVLconst [c*d])
+(MULWconst [c] (MOVWconst [d])) -> (MOVWconst [c*d])
+(MULBconst [c] (MOVBconst [d])) -> (MOVBconst [c*d])
+(ANDQconst [c] (MOVQconst [d])) -> (MOVQconst [c&d])
+(ANDLconst [c] (MOVLconst [d])) -> (MOVLconst [c&d])
+(ANDWconst [c] (MOVWconst [d])) -> (MOVWconst [c&d])
+(ANDBconst [c] (MOVBconst [d])) -> (MOVBconst [c&d])
+(ORQconst [c] (MOVQconst [d])) -> (MOVQconst [c|d])
+(ORLconst [c] (MOVLconst [d])) -> (MOVLconst [c|d])
+(ORWconst [c] (MOVWconst [d])) -> (MOVWconst [c|d])
+(ORBconst [c] (MOVBconst [d])) -> (MOVBconst [c|d])
+(XORQconst [c] (MOVQconst [d])) -> (MOVQconst [c^d])
+(XORLconst [c] (MOVLconst [d])) -> (MOVLconst [c^d])
+(XORWconst [c] (MOVWconst [d])) -> (MOVWconst [c^d])
+(XORBconst [c] (MOVBconst [d])) -> (MOVBconst [c^d])
+(NOTQ (MOVQconst [c])) -> (MOVQconst [^c])
+(NOTL (MOVLconst [c])) -> (MOVLconst [^c])
+(NOTW (MOVWconst [c])) -> (MOVWconst [^c])
+(NOTB (MOVBconst [c])) -> (MOVBconst [^c])
+
+// generic simplifications
+// TODO: more of this
+(ADDQ x (NEGQ y)) -> (SUBQ x y)
+(ADDL x (NEGL y)) -> (SUBL x y)
+(ADDW x (NEGW y)) -> (SUBW x y)
+(ADDB x (NEGB y)) -> (SUBB x y)
+(SUBQ x x) -> (MOVQconst [0])
+(SUBL x x) -> (MOVLconst [0])
+(SUBW x x) -> (MOVWconst [0])
+(SUBB x x) -> (MOVBconst [0])
+(ANDQ x x) -> x
+(ANDL x x) -> x
+(ANDW x x) -> x
+(ANDB x x) -> x
+(ORQ x x) -> x
+(ORL x x) -> x
+(ORW x x) -> x
+(ORB x x) -> x
+(XORQ x x) -> (MOVQconst [0])
+(XORL x x) -> (MOVLconst [0])
+(XORW x x) -> (MOVWconst [0])
+(XORB x x) -> (MOVBconst [0])
+
+// checking AND against 0.
+(CMPQconst (ANDQ x y) [0]) -> (TESTQ x y)
+(CMPLconst (ANDL x y) [0]) -> (TESTL x y)
+(CMPWconst (ANDW x y) [0]) -> (TESTW x y)
+(CMPBconst (ANDB x y) [0]) -> (TESTB x y)
+(CMPQconst (ANDQconst [c] x) [0]) -> (TESTQconst [c] x)
+(CMPLconst (ANDLconst [c] x) [0]) -> (TESTLconst [c] x)
+(CMPWconst (ANDWconst [c] x) [0]) -> (TESTWconst [c] x)
+(CMPBconst (ANDBconst [c] x) [0]) -> (TESTBconst [c] x)
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
new file mode 100644
index 0000000..af08d18
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -0,0 +1,535 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "strings"
+
+// copied from ../../amd64/reg.go
+var regNamesAMD64 = []string{
+ ".AX",
+ ".CX",
+ ".DX",
+ ".BX",
+ ".SP",
+ ".BP",
+ ".SI",
+ ".DI",
+ ".R8",
+ ".R9",
+ ".R10",
+ ".R11",
+ ".R12",
+ ".R13",
+ ".R14",
+ ".R15",
+ ".X0",
+ ".X1",
+ ".X2",
+ ".X3",
+ ".X4",
+ ".X5",
+ ".X6",
+ ".X7",
+ ".X8",
+ ".X9",
+ ".X10",
+ ".X11",
+ ".X12",
+ ".X13",
+ ".X14",
+ ".X15",
+
+ // pseudo-registers
+ ".SB",
+ ".FLAGS",
+}
+
+func init() {
+ // Make map from reg names to reg integers.
+ if len(regNamesAMD64) > 64 {
+ panic("too many registers")
+ }
+ num := map[string]int{}
+ for i, name := range regNamesAMD64 {
+ if name[0] != '.' {
+ panic("register name " + name + " does not start with '.'")
+ }
+ num[name[1:]] = i
+ }
+ buildReg := func(s string) regMask {
+ m := regMask(0)
+ for _, r := range strings.Split(s, " ") {
+ if n, ok := num[r]; ok {
+ m |= regMask(1) << uint(n)
+ continue
+ }
+ panic("register " + r + " not found")
+ }
+ return m
+ }
+
+ // Common individual register masks
+ var (
+ ax = buildReg("AX")
+ cx = buildReg("CX")
+ dx = buildReg("DX")
+ x15 = buildReg("X15")
+ gp = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+ fp = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15")
+ gpsp = gp | buildReg("SP")
+ gpspsb = gpsp | buildReg("SB")
+ flags = buildReg("FLAGS")
+ callerSave = gp | fp | flags
+ )
+ // Common slices of register masks
+ var (
+ gponly = []regMask{gp}
+ fponly = []regMask{fp}
+ flagsonly = []regMask{flags}
+ )
+
+ // Common regInfo
+ var (
+ gp01 = regInfo{inputs: []regMask{}, outputs: gponly}
+ gp11 = regInfo{inputs: []regMask{gpsp}, outputs: gponly, clobbers: flags}
+ gp11nf = regInfo{inputs: []regMask{gpsp}, outputs: gponly} // nf: no flags clobbered
+ gp11sb = regInfo{inputs: []regMask{gpspsb}, outputs: gponly}
+ gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly, clobbers: flags}
+ gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly}
+ gp21shift = regInfo{inputs: []regMask{gpsp, cx}, outputs: []regMask{gp &^ cx}, clobbers: flags}
+ gp11div = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{ax},
+ clobbers: dx | flags}
+ gp11hmul = regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{dx},
+ clobbers: ax | flags}
+ gp11mod = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{dx},
+ clobbers: ax | flags}
+
+ gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly}
+ gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly}
+ flagsgp = regInfo{inputs: flagsonly, outputs: gponly}
+ readflags = regInfo{inputs: flagsonly, outputs: gponly}
+ flagsgpax = regInfo{inputs: flagsonly, clobbers: ax | flags, outputs: []regMask{gp &^ ax}}
+
+ gpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly}
+ gploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly}
+
+ gpstore = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
+ gpstoreconst = regInfo{inputs: []regMask{gpspsb, 0}}
+ gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}}
+ gpstoreconstidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
+
+ fp01 = regInfo{inputs: []regMask{}, outputs: fponly}
+ fp21 = regInfo{inputs: []regMask{fp, fp}, outputs: fponly}
+ fp21x15 = regInfo{inputs: []regMask{fp &^ x15, fp &^ x15},
+ clobbers: x15, outputs: []regMask{fp &^ x15}}
+ fpgp = regInfo{inputs: fponly, outputs: gponly}
+ gpfp = regInfo{inputs: gponly, outputs: fponly}
+ fp11 = regInfo{inputs: fponly, outputs: fponly}
+ fp2flags = regInfo{inputs: []regMask{fp, fp}, outputs: flagsonly}
+ // fp1flags = regInfo{inputs: fponly, outputs: flagsonly}
+
+ fpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: fponly}
+ fploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: fponly}
+
+ fpstore = regInfo{inputs: []regMask{gpspsb, fp, 0}}
+ fpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, fp, 0}}
+ )
+ // TODO: most ops clobber flags
+
+ // Suffixes encode the bit width of various instructions.
+ // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit
+
+ // TODO: 2-address instructions. Mark ops as needing matching input/output regs.
+ var AMD64ops = []opData{
+ // fp ops
+ {name: "ADDSS", argLength: 2, reg: fp21, asm: "ADDSS"}, // fp32 add
+ {name: "ADDSD", argLength: 2, reg: fp21, asm: "ADDSD"}, // fp64 add
+ {name: "SUBSS", argLength: 2, reg: fp21x15, asm: "SUBSS"}, // fp32 sub
+ {name: "SUBSD", argLength: 2, reg: fp21x15, asm: "SUBSD"}, // fp64 sub
+ {name: "MULSS", argLength: 2, reg: fp21, asm: "MULSS"}, // fp32 mul
+ {name: "MULSD", argLength: 2, reg: fp21, asm: "MULSD"}, // fp64 mul
+ {name: "DIVSS", argLength: 2, reg: fp21x15, asm: "DIVSS"}, // fp32 div
+ {name: "DIVSD", argLength: 2, reg: fp21x15, asm: "DIVSD"}, // fp64 div
+
+ {name: "MOVSSload", argLength: 2, reg: fpload, asm: "MOVSS", aux: "SymOff"}, // fp32 load
+ {name: "MOVSDload", argLength: 2, reg: fpload, asm: "MOVSD", aux: "SymOff"}, // fp64 load
+ {name: "MOVSSconst", reg: fp01, asm: "MOVSS", aux: "Float", rematerializeable: true}, // fp32 constant
+ {name: "MOVSDconst", reg: fp01, asm: "MOVSD", aux: "Float", rematerializeable: true}, // fp64 constant
+ {name: "MOVSSloadidx4", argLength: 3, reg: fploadidx, asm: "MOVSS", aux: "SymOff"}, // fp32 load
+ {name: "MOVSDloadidx8", argLength: 3, reg: fploadidx, asm: "MOVSD", aux: "SymOff"}, // fp64 load
+
+ {name: "MOVSSstore", argLength: 3, reg: fpstore, asm: "MOVSS", aux: "SymOff"}, // fp32 store
+ {name: "MOVSDstore", argLength: 3, reg: fpstore, asm: "MOVSD", aux: "SymOff"}, // fp64 store
+ {name: "MOVSSstoreidx4", argLength: 4, reg: fpstoreidx, asm: "MOVSS", aux: "SymOff"}, // fp32 indexed by 4i store
+ {name: "MOVSDstoreidx8", argLength: 4, reg: fpstoreidx, asm: "MOVSD", aux: "SymOff"}, // fp64 indexed by 8i store
+
+ // binary ops
+ {name: "ADDQ", argLength: 2, reg: gp21, asm: "ADDQ"}, // arg0 + arg1
+ {name: "ADDL", argLength: 2, reg: gp21, asm: "ADDL"}, // arg0 + arg1
+ {name: "ADDW", argLength: 2, reg: gp21, asm: "ADDL"}, // arg0 + arg1
+ {name: "ADDB", argLength: 2, reg: gp21, asm: "ADDL"}, // arg0 + arg1
+ {name: "ADDQconst", argLength: 1, reg: gp11, asm: "ADDQ", aux: "Int64", typ: "UInt64"}, // arg0 + auxint
+ {name: "ADDLconst", argLength: 1, reg: gp11, asm: "ADDL", aux: "Int32"}, // arg0 + auxint
+ {name: "ADDWconst", argLength: 1, reg: gp11, asm: "ADDL", aux: "Int16"}, // arg0 + auxint
+ {name: "ADDBconst", argLength: 1, reg: gp11, asm: "ADDL", aux: "Int8"}, // arg0 + auxint
+
+ {name: "SUBQ", argLength: 2, reg: gp21, asm: "SUBQ"}, // arg0 - arg1
+ {name: "SUBL", argLength: 2, reg: gp21, asm: "SUBL"}, // arg0 - arg1
+ {name: "SUBW", argLength: 2, reg: gp21, asm: "SUBL"}, // arg0 - arg1
+ {name: "SUBB", argLength: 2, reg: gp21, asm: "SUBL"}, // arg0 - arg1
+ {name: "SUBQconst", argLength: 1, reg: gp11, asm: "SUBQ", aux: "Int64"}, // arg0 - auxint
+ {name: "SUBLconst", argLength: 1, reg: gp11, asm: "SUBL", aux: "Int32"}, // arg0 - auxint
+ {name: "SUBWconst", argLength: 1, reg: gp11, asm: "SUBL", aux: "Int16"}, // arg0 - auxint
+ {name: "SUBBconst", argLength: 1, reg: gp11, asm: "SUBL", aux: "Int8"}, // arg0 - auxint
+
+ {name: "MULQ", argLength: 2, reg: gp21, asm: "IMULQ"}, // arg0 * arg1
+ {name: "MULL", argLength: 2, reg: gp21, asm: "IMULL"}, // arg0 * arg1
+ {name: "MULW", argLength: 2, reg: gp21, asm: "IMULW"}, // arg0 * arg1
+ {name: "MULB", argLength: 2, reg: gp21, asm: "IMULW"}, // arg0 * arg1
+ {name: "MULQconst", argLength: 1, reg: gp11, asm: "IMULQ", aux: "Int64"}, // arg0 * auxint
+ {name: "MULLconst", argLength: 1, reg: gp11, asm: "IMULL", aux: "Int32"}, // arg0 * auxint
+ {name: "MULWconst", argLength: 1, reg: gp11, asm: "IMULW", aux: "Int16"}, // arg0 * auxint
+ {name: "MULBconst", argLength: 1, reg: gp11, asm: "IMULW", aux: "Int8"}, // arg0 * auxint
+
+ {name: "HMULQ", argLength: 2, reg: gp11hmul, asm: "IMULQ"}, // (arg0 * arg1) >> width
+ {name: "HMULL", argLength: 2, reg: gp11hmul, asm: "IMULL"}, // (arg0 * arg1) >> width
+ {name: "HMULW", argLength: 2, reg: gp11hmul, asm: "IMULW"}, // (arg0 * arg1) >> width
+ {name: "HMULB", argLength: 2, reg: gp11hmul, asm: "IMULB"}, // (arg0 * arg1) >> width
+ {name: "HMULQU", argLength: 2, reg: gp11hmul, asm: "MULQ"}, // (arg0 * arg1) >> width
+ {name: "HMULLU", argLength: 2, reg: gp11hmul, asm: "MULL"}, // (arg0 * arg1) >> width
+ {name: "HMULWU", argLength: 2, reg: gp11hmul, asm: "MULW"}, // (arg0 * arg1) >> width
+ {name: "HMULBU", argLength: 2, reg: gp11hmul, asm: "MULB"}, // (arg0 * arg1) >> width
+
+ {name: "AVGQU", argLength: 2, reg: gp21}, // (arg0 + arg1) / 2 as unsigned, all 64 result bits
+
+ {name: "DIVQ", argLength: 2, reg: gp11div, asm: "IDIVQ"}, // arg0 / arg1
+ {name: "DIVL", argLength: 2, reg: gp11div, asm: "IDIVL"}, // arg0 / arg1
+ {name: "DIVW", argLength: 2, reg: gp11div, asm: "IDIVW"}, // arg0 / arg1
+ {name: "DIVQU", argLength: 2, reg: gp11div, asm: "DIVQ"}, // arg0 / arg1
+ {name: "DIVLU", argLength: 2, reg: gp11div, asm: "DIVL"}, // arg0 / arg1
+ {name: "DIVWU", argLength: 2, reg: gp11div, asm: "DIVW"}, // arg0 / arg1
+
+ {name: "MODQ", argLength: 2, reg: gp11mod, asm: "IDIVQ"}, // arg0 % arg1
+ {name: "MODL", argLength: 2, reg: gp11mod, asm: "IDIVL"}, // arg0 % arg1
+ {name: "MODW", argLength: 2, reg: gp11mod, asm: "IDIVW"}, // arg0 % arg1
+ {name: "MODQU", argLength: 2, reg: gp11mod, asm: "DIVQ"}, // arg0 % arg1
+ {name: "MODLU", argLength: 2, reg: gp11mod, asm: "DIVL"}, // arg0 % arg1
+ {name: "MODWU", argLength: 2, reg: gp11mod, asm: "DIVW"}, // arg0 % arg1
+
+ {name: "ANDQ", argLength: 2, reg: gp21, asm: "ANDQ"}, // arg0 & arg1
+ {name: "ANDL", argLength: 2, reg: gp21, asm: "ANDL"}, // arg0 & arg1
+ {name: "ANDW", argLength: 2, reg: gp21, asm: "ANDL"}, // arg0 & arg1
+ {name: "ANDB", argLength: 2, reg: gp21, asm: "ANDL"}, // arg0 & arg1
+ {name: "ANDQconst", argLength: 1, reg: gp11, asm: "ANDQ", aux: "Int64"}, // arg0 & auxint
+ {name: "ANDLconst", argLength: 1, reg: gp11, asm: "ANDL", aux: "Int32"}, // arg0 & auxint
+ {name: "ANDWconst", argLength: 1, reg: gp11, asm: "ANDL", aux: "Int16"}, // arg0 & auxint
+ {name: "ANDBconst", argLength: 1, reg: gp11, asm: "ANDL", aux: "Int8"}, // arg0 & auxint
+
+ {name: "ORQ", argLength: 2, reg: gp21, asm: "ORQ"}, // arg0 | arg1
+ {name: "ORL", argLength: 2, reg: gp21, asm: "ORL"}, // arg0 | arg1
+ {name: "ORW", argLength: 2, reg: gp21, asm: "ORL"}, // arg0 | arg1
+ {name: "ORB", argLength: 2, reg: gp21, asm: "ORL"}, // arg0 | arg1
+ {name: "ORQconst", argLength: 1, reg: gp11, asm: "ORQ", aux: "Int64"}, // arg0 | auxint
+ {name: "ORLconst", argLength: 1, reg: gp11, asm: "ORL", aux: "Int32"}, // arg0 | auxint
+ {name: "ORWconst", argLength: 1, reg: gp11, asm: "ORL", aux: "Int16"}, // arg0 | auxint
+ {name: "ORBconst", argLength: 1, reg: gp11, asm: "ORL", aux: "Int8"}, // arg0 | auxint
+
+ {name: "XORQ", argLength: 2, reg: gp21, asm: "XORQ"}, // arg0 ^ arg1
+ {name: "XORL", argLength: 2, reg: gp21, asm: "XORL"}, // arg0 ^ arg1
+ {name: "XORW", argLength: 2, reg: gp21, asm: "XORL"}, // arg0 ^ arg1
+ {name: "XORB", argLength: 2, reg: gp21, asm: "XORL"}, // arg0 ^ arg1
+ {name: "XORQconst", argLength: 1, reg: gp11, asm: "XORQ", aux: "Int64"}, // arg0 ^ auxint
+ {name: "XORLconst", argLength: 1, reg: gp11, asm: "XORL", aux: "Int32"}, // arg0 ^ auxint
+ {name: "XORWconst", argLength: 1, reg: gp11, asm: "XORL", aux: "Int16"}, // arg0 ^ auxint
+ {name: "XORBconst", argLength: 1, reg: gp11, asm: "XORL", aux: "Int8"}, // arg0 ^ auxint
+
+ {name: "CMPQ", argLength: 2, reg: gp2flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to arg1
+ {name: "CMPL", argLength: 2, reg: gp2flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to arg1
+ {name: "CMPW", argLength: 2, reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1
+ {name: "CMPB", argLength: 2, reg: gp2flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to arg1
+ {name: "CMPQconst", argLength: 1, reg: gp1flags, asm: "CMPQ", typ: "Flags", aux: "Int64"}, // arg0 compare to auxint
+ {name: "CMPLconst", argLength: 1, reg: gp1flags, asm: "CMPL", typ: "Flags", aux: "Int32"}, // arg0 compare to auxint
+ {name: "CMPWconst", argLength: 1, reg: gp1flags, asm: "CMPW", typ: "Flags", aux: "Int16"}, // arg0 compare to auxint
+ {name: "CMPBconst", argLength: 1, reg: gp1flags, asm: "CMPB", typ: "Flags", aux: "Int8"}, // arg0 compare to auxint
+
+ {name: "UCOMISS", argLength: 2, reg: fp2flags, asm: "UCOMISS", typ: "Flags"}, // arg0 compare to arg1, f32
+ {name: "UCOMISD", argLength: 2, reg: fp2flags, asm: "UCOMISD", typ: "Flags"}, // arg0 compare to arg1, f64
+
+ {name: "TESTQ", argLength: 2, reg: gp2flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0
+ {name: "TESTL", argLength: 2, reg: gp2flags, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0
+ {name: "TESTW", argLength: 2, reg: gp2flags, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0
+ {name: "TESTB", argLength: 2, reg: gp2flags, asm: "TESTB", typ: "Flags"}, // (arg0 & arg1) compare to 0
+ {name: "TESTQconst", argLength: 1, reg: gp1flags, asm: "TESTQ", typ: "Flags", aux: "Int64"}, // (arg0 & auxint) compare to 0
+ {name: "TESTLconst", argLength: 1, reg: gp1flags, asm: "TESTL", typ: "Flags", aux: "Int32"}, // (arg0 & auxint) compare to 0
+ {name: "TESTWconst", argLength: 1, reg: gp1flags, asm: "TESTW", typ: "Flags", aux: "Int16"}, // (arg0 & auxint) compare to 0
+ {name: "TESTBconst", argLength: 1, reg: gp1flags, asm: "TESTB", typ: "Flags", aux: "Int8"}, // (arg0 & auxint) compare to 0
+
+ {name: "SHLQ", argLength: 2, reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64
+ {name: "SHLL", argLength: 2, reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32
+ {name: "SHLW", argLength: 2, reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32
+ {name: "SHLB", argLength: 2, reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32
+ {name: "SHLQconst", argLength: 1, reg: gp11, asm: "SHLQ", aux: "Int64"}, // arg0 << auxint, shift amount 0-63
+ {name: "SHLLconst", argLength: 1, reg: gp11, asm: "SHLL", aux: "Int32"}, // arg0 << auxint, shift amount 0-31
+ {name: "SHLWconst", argLength: 1, reg: gp11, asm: "SHLL", aux: "Int16"}, // arg0 << auxint, shift amount 0-31
+ {name: "SHLBconst", argLength: 1, reg: gp11, asm: "SHLL", aux: "Int8"}, // arg0 << auxint, shift amount 0-31
+ // Note: x86 is weird, the 16 and 8 byte shifts still use all 5 bits of shift amount!
+
+ {name: "SHRQ", argLength: 2, reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64
+ {name: "SHRL", argLength: 2, reg: gp21shift, asm: "SHRL"}, // unsigned arg0 >> arg1, shift amount is mod 32
+ {name: "SHRW", argLength: 2, reg: gp21shift, asm: "SHRW"}, // unsigned arg0 >> arg1, shift amount is mod 32
+ {name: "SHRB", argLength: 2, reg: gp21shift, asm: "SHRB"}, // unsigned arg0 >> arg1, shift amount is mod 32
+ {name: "SHRQconst", argLength: 1, reg: gp11, asm: "SHRQ", aux: "Int64"}, // unsigned arg0 >> auxint, shift amount 0-63
+ {name: "SHRLconst", argLength: 1, reg: gp11, asm: "SHRL", aux: "Int32"}, // unsigned arg0 >> auxint, shift amount 0-31
+ {name: "SHRWconst", argLength: 1, reg: gp11, asm: "SHRW", aux: "Int16"}, // unsigned arg0 >> auxint, shift amount 0-31
+ {name: "SHRBconst", argLength: 1, reg: gp11, asm: "SHRB", aux: "Int8"}, // unsigned arg0 >> auxint, shift amount 0-31
+
+ {name: "SARQ", argLength: 2, reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64
+ {name: "SARL", argLength: 2, reg: gp21shift, asm: "SARL"}, // signed arg0 >> arg1, shift amount is mod 32
+ {name: "SARW", argLength: 2, reg: gp21shift, asm: "SARW"}, // signed arg0 >> arg1, shift amount is mod 32
+ {name: "SARB", argLength: 2, reg: gp21shift, asm: "SARB"}, // signed arg0 >> arg1, shift amount is mod 32
+ {name: "SARQconst", argLength: 1, reg: gp11, asm: "SARQ", aux: "Int64"}, // signed arg0 >> auxint, shift amount 0-63
+ {name: "SARLconst", argLength: 1, reg: gp11, asm: "SARL", aux: "Int32"}, // signed arg0 >> auxint, shift amount 0-31
+ {name: "SARWconst", argLength: 1, reg: gp11, asm: "SARW", aux: "Int16"}, // signed arg0 >> auxint, shift amount 0-31
+ {name: "SARBconst", argLength: 1, reg: gp11, asm: "SARB", aux: "Int8"}, // signed arg0 >> auxint, shift amount 0-31
+
+ {name: "ROLQconst", argLength: 1, reg: gp11, asm: "ROLQ", aux: "Int64"}, // arg0 rotate left auxint, rotate amount 0-63
+ {name: "ROLLconst", argLength: 1, reg: gp11, asm: "ROLL", aux: "Int32"}, // arg0 rotate left auxint, rotate amount 0-31
+ {name: "ROLWconst", argLength: 1, reg: gp11, asm: "ROLW", aux: "Int16"}, // arg0 rotate left auxint, rotate amount 0-15
+ {name: "ROLBconst", argLength: 1, reg: gp11, asm: "ROLB", aux: "Int8"}, // arg0 rotate left auxint, rotate amount 0-7
+
+ // unary ops
+ {name: "NEGQ", argLength: 1, reg: gp11, asm: "NEGQ"}, // -arg0
+ {name: "NEGL", argLength: 1, reg: gp11, asm: "NEGL"}, // -arg0
+ {name: "NEGW", argLength: 1, reg: gp11, asm: "NEGL"}, // -arg0
+ {name: "NEGB", argLength: 1, reg: gp11, asm: "NEGL"}, // -arg0
+
+ {name: "NOTQ", argLength: 1, reg: gp11, asm: "NOTQ"}, // ^arg0
+ {name: "NOTL", argLength: 1, reg: gp11, asm: "NOTL"}, // ^arg0
+ {name: "NOTW", argLength: 1, reg: gp11, asm: "NOTL"}, // ^arg0
+ {name: "NOTB", argLength: 1, reg: gp11, asm: "NOTL"}, // ^arg0
+
+ {name: "SQRTSD", argLength: 1, reg: fp11, asm: "SQRTSD"}, // sqrt(arg0)
+
+ {name: "SBBQcarrymask", argLength: 1, reg: flagsgp, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear.
+ {name: "SBBLcarrymask", argLength: 1, reg: flagsgp, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear.
+ // Note: SBBW and SBBB are subsumed by SBBL
+
+ {name: "SETEQ", argLength: 1, reg: readflags, asm: "SETEQ"}, // extract == condition from arg0
+ {name: "SETNE", argLength: 1, reg: readflags, asm: "SETNE"}, // extract != condition from arg0
+ {name: "SETL", argLength: 1, reg: readflags, asm: "SETLT"}, // extract signed < condition from arg0
+ {name: "SETLE", argLength: 1, reg: readflags, asm: "SETLE"}, // extract signed <= condition from arg0
+ {name: "SETG", argLength: 1, reg: readflags, asm: "SETGT"}, // extract signed > condition from arg0
+ {name: "SETGE", argLength: 1, reg: readflags, asm: "SETGE"}, // extract signed >= condition from arg0
+ {name: "SETB", argLength: 1, reg: readflags, asm: "SETCS"}, // extract unsigned < condition from arg0
+ {name: "SETBE", argLength: 1, reg: readflags, asm: "SETLS"}, // extract unsigned <= condition from arg0
+ {name: "SETA", argLength: 1, reg: readflags, asm: "SETHI"}, // extract unsigned > condition from arg0
+ {name: "SETAE", argLength: 1, reg: readflags, asm: "SETCC"}, // extract unsigned >= condition from arg0
+ // Need different opcodes for floating point conditions because
+ // any comparison involving a NaN is always FALSE and thus
+ // the patterns for inverting conditions cannot be used.
+ {name: "SETEQF", argLength: 1, reg: flagsgpax, asm: "SETEQ"}, // extract == condition from arg0
+ {name: "SETNEF", argLength: 1, reg: flagsgpax, asm: "SETNE"}, // extract != condition from arg0
+ {name: "SETORD", argLength: 1, reg: flagsgp, asm: "SETPC"}, // extract "ordered" (No Nan present) condition from arg0
+ {name: "SETNAN", argLength: 1, reg: flagsgp, asm: "SETPS"}, // extract "unordered" (Nan present) condition from arg0
+
+ {name: "SETGF", argLength: 1, reg: flagsgp, asm: "SETHI"}, // extract floating > condition from arg0
+ {name: "SETGEF", argLength: 1, reg: flagsgp, asm: "SETCC"}, // extract floating >= condition from arg0
+
+ {name: "MOVBQSX", argLength: 1, reg: gp11nf, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64
+ {name: "MOVBQZX", argLength: 1, reg: gp11nf, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64
+ {name: "MOVWQSX", argLength: 1, reg: gp11nf, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64
+ {name: "MOVWQZX", argLength: 1, reg: gp11nf, asm: "MOVWQZX"}, // zero extend arg0 from int16 to int64
+ {name: "MOVLQSX", argLength: 1, reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64
+ {name: "MOVLQZX", argLength: 1, reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64
+
+ {name: "MOVBconst", reg: gp01, asm: "MOVB", typ: "UInt8", aux: "Int8", rematerializeable: true}, // 8 low bits of auxint
+ {name: "MOVWconst", reg: gp01, asm: "MOVW", typ: "UInt16", aux: "Int16", rematerializeable: true}, // 16 low bits of auxint
+ {name: "MOVLconst", reg: gp01, asm: "MOVL", typ: "UInt32", aux: "Int32", rematerializeable: true}, // 32 low bits of auxint
+ {name: "MOVQconst", reg: gp01, asm: "MOVQ", typ: "UInt64", aux: "Int64", rematerializeable: true}, // auxint
+
+ {name: "CVTTSD2SL", argLength: 1, reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32
+ {name: "CVTTSD2SQ", argLength: 1, reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64
+ {name: "CVTTSS2SL", argLength: 1, reg: fpgp, asm: "CVTTSS2SL"}, // convert float32 to int32
+ {name: "CVTTSS2SQ", argLength: 1, reg: fpgp, asm: "CVTTSS2SQ"}, // convert float32 to int64
+ {name: "CVTSL2SS", argLength: 1, reg: gpfp, asm: "CVTSL2SS"}, // convert int32 to float32
+ {name: "CVTSL2SD", argLength: 1, reg: gpfp, asm: "CVTSL2SD"}, // convert int32 to float64
+ {name: "CVTSQ2SS", argLength: 1, reg: gpfp, asm: "CVTSQ2SS"}, // convert int64 to float32
+ {name: "CVTSQ2SD", argLength: 1, reg: gpfp, asm: "CVTSQ2SD"}, // convert int64 to float64
+ {name: "CVTSD2SS", argLength: 1, reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32
+ {name: "CVTSS2SD", argLength: 1, reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64
+
+ {name: "PXOR", argLength: 2, reg: fp21, asm: "PXOR"}, // exclusive or, applied to X regs for float negation.
+
+ {name: "LEAQ", argLength: 1, reg: gp11sb, aux: "SymOff", rematerializeable: true}, // arg0 + auxint + offset encoded in aux
+ {name: "LEAQ1", argLength: 2, reg: gp21sb, aux: "SymOff"}, // arg0 + arg1 + auxint + aux
+ {name: "LEAQ2", argLength: 2, reg: gp21sb, aux: "SymOff"}, // arg0 + 2*arg1 + auxint + aux
+ {name: "LEAQ4", argLength: 2, reg: gp21sb, aux: "SymOff"}, // arg0 + 4*arg1 + auxint + aux
+ {name: "LEAQ8", argLength: 2, reg: gp21sb, aux: "SymOff"}, // arg0 + 8*arg1 + auxint + aux
+ // Note: LEAQ{1,2,4,8} must not have OpSB as either argument.
+
+ // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address
+ {name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem
+ {name: "MOVBQSXload", argLength: 2, reg: gpload, asm: "MOVBQSX", aux: "SymOff"}, // ditto, extend to int64
+ {name: "MOVBQZXload", argLength: 2, reg: gpload, asm: "MOVBQZX", aux: "SymOff"}, // ditto, extend to uint64
+ {name: "MOVWload", argLength: 2, reg: gpload, asm: "MOVWLZX", aux: "SymOff", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem
+ {name: "MOVWQSXload", argLength: 2, reg: gpload, asm: "MOVWQSX", aux: "SymOff"}, // ditto, extend to int64
+ {name: "MOVWQZXload", argLength: 2, reg: gpload, asm: "MOVWQZX", aux: "SymOff"}, // ditto, extend to uint64
+ {name: "MOVLload", argLength: 2, reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem
+ {name: "MOVLQSXload", argLength: 2, reg: gpload, asm: "MOVLQSX", aux: "SymOff"}, // ditto, extend to int64
+ {name: "MOVLQZXload", argLength: 2, reg: gpload, asm: "MOVLQZX", aux: "SymOff"}, // ditto, extend to uint64
+ {name: "MOVQload", argLength: 2, reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem
+ {name: "MOVBstore", argLength: 3, reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem
+ {name: "MOVWstore", argLength: 3, reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem
+ {name: "MOVLstore", argLength: 3, reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem
+ {name: "MOVQstore", argLength: 3, reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem
+ {name: "MOVOload", argLength: 2, reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem
+ {name: "MOVOstore", argLength: 3, reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem
+
+ // indexed loads/stores
+ {name: "MOVBloadidx1", argLength: 3, reg: gploadidx, asm: "MOVBLZX", aux: "SymOff"}, // load a byte from arg0+arg1+auxint+aux. arg2=mem
+ {name: "MOVWloadidx2", argLength: 3, reg: gploadidx, asm: "MOVWLZX", aux: "SymOff"}, // load 2 bytes from arg0+2*arg1+auxint+aux. arg2=mem
+ {name: "MOVLloadidx4", argLength: 3, reg: gploadidx, asm: "MOVL", aux: "SymOff"}, // load 4 bytes from arg0+4*arg1+auxint+aux. arg2=mem
+ {name: "MOVQloadidx8", argLength: 3, reg: gploadidx, asm: "MOVQ", aux: "SymOff"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem
+ // TODO: sign-extending indexed loads
+ {name: "MOVBstoreidx1", argLength: 4, reg: gpstoreidx, asm: "MOVB", aux: "SymOff"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem
+ {name: "MOVWstoreidx2", argLength: 4, reg: gpstoreidx, asm: "MOVW", aux: "SymOff"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem
+ {name: "MOVLstoreidx4", argLength: 4, reg: gpstoreidx, asm: "MOVL", aux: "SymOff"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem
+ {name: "MOVQstoreidx8", argLength: 4, reg: gpstoreidx, asm: "MOVQ", aux: "SymOff"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem
+ // TODO: add size-mismatched indexed loads, like MOVBstoreidx4.
+
+ // For storeconst ops, the AuxInt field encodes both
+ // the value to store and an address offset of the store.
+ // Cast AuxInt to a ValAndOff to extract Val and Off fields.
+ {name: "MOVBstoreconst", argLength: 2, reg: gpstoreconst, asm: "MOVB", aux: "SymValAndOff", typ: "Mem"}, // store low byte of ValAndOff(AuxInt).Val() to arg0+ValAndOff(AuxInt).Off()+aux. arg1=mem
+ {name: "MOVWstoreconst", argLength: 2, reg: gpstoreconst, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ...
+ {name: "MOVLstoreconst", argLength: 2, reg: gpstoreconst, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ...
+ {name: "MOVQstoreconst", argLength: 2, reg: gpstoreconst, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ...
+
+ {name: "MOVBstoreconstidx1", argLength: 3, reg: gpstoreconstidx, asm: "MOVB", aux: "SymValAndOff", typ: "Mem"}, // store low byte of ValAndOff(AuxInt).Val() to arg0+1*arg1+ValAndOff(AuxInt).Off()+aux. arg2=mem
+ {name: "MOVWstoreconstidx2", argLength: 3, reg: gpstoreconstidx, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ... 2*arg1 ...
+ {name: "MOVLstoreconstidx4", argLength: 3, reg: gpstoreconstidx, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... 4*arg1 ...
+ {name: "MOVQstoreconstidx8", argLength: 3, reg: gpstoreconstidx, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ... 8*arg1 ...
+
+ // arg0 = (duff-adjusted) pointer to start of memory to zero
+ // arg1 = value to store (will always be zero)
+ // arg2 = mem
+ // auxint = offset into duffzero code to start executing
+ // returns mem
+ {
+ name: "DUFFZERO",
+ aux: "Int64",
+ argLength: 3,
+ reg: regInfo{
+ inputs: []regMask{buildReg("DI"), buildReg("X0")},
+ clobbers: buildReg("DI FLAGS"),
+ },
+ },
+ {name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Int128", rematerializeable: true},
+
+ // arg0 = address of memory to zero
+ // arg1 = # of 8-byte words to zero
+ // arg2 = value to store (will always be zero)
+ // arg3 = mem
+ // returns mem
+ {
+ name: "REPSTOSQ",
+ argLength: 4,
+ reg: regInfo{
+ inputs: []regMask{buildReg("DI"), buildReg("CX"), buildReg("AX")},
+ clobbers: buildReg("DI CX FLAGS"),
+ },
+ },
+
+ {name: "CALLstatic", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "SymOff"}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem
+ {name: "CALLclosure", argLength: 3, reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}, aux: "Int64"}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem
+ {name: "CALLdefer", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call deferproc. arg0=mem, auxint=argsize, returns mem
+ {name: "CALLgo", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call newproc. arg0=mem, auxint=argsize, returns mem
+ {name: "CALLinter", argLength: 2, reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "Int64"}, // call fn by pointer. arg0=codeptr, arg1=mem, auxint=argsize, returns mem
+
+ // arg0 = destination pointer
+ // arg1 = source pointer
+ // arg2 = mem
+ // auxint = offset from duffcopy symbol to call
+ // returns memory
+ {
+ name: "DUFFCOPY",
+ aux: "Int64",
+ argLength: 3,
+ reg: regInfo{
+ inputs: []regMask{buildReg("DI"), buildReg("SI")},
+ clobbers: buildReg("DI SI X0 FLAGS"), // uses X0 as a temporary
+ },
+ },
+
+ // arg0 = destination pointer
+ // arg1 = source pointer
+ // arg2 = # of 8-byte words to copy
+ // arg3 = mem
+ // returns memory
+ {
+ name: "REPMOVSQ",
+ argLength: 4,
+ reg: regInfo{
+ inputs: []regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")},
+ clobbers: buildReg("DI SI CX"),
+ },
+ },
+
+ // (InvertFlags (CMPQ a b)) == (CMPQ b a)
+ // So if we want (SETL (CMPQ a b)) but we can't do that because a is a constant,
+ // then we do (SETL (InvertFlags (CMPQ b a))) instead.
+ // Rewrites will convert this to (SETG (CMPQ b a)).
+ // InvertFlags is a pseudo-op which can't appear in assembly output.
+ {name: "InvertFlags", argLength: 1}, // reverse direction of arg0
+
+ // Pseudo-ops
+ {name: "LoweredGetG", argLength: 1, reg: gp01}, // arg0=mem
+ // Scheduler ensures LoweredGetClosurePtr occurs only in entry block,
+ // and sorts it to the very beginning of the block to prevent other
+ // use of DX (the closure pointer)
+ {name: "LoweredGetClosurePtr", reg: regInfo{outputs: []regMask{buildReg("DX")}}},
+ //arg0=ptr,arg1=mem, returns void. Faults if ptr is nil.
+ {name: "LoweredNilCheck", argLength: 2, reg: regInfo{inputs: []regMask{gpsp}, clobbers: flags}},
+
+ // MOVQconvert 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: "MOVQconvert", argLength: 2, reg: gp11nf, asm: "MOVQ"},
+
+ // Constant flag values. For any comparison, there are 5 possible
+ // outcomes: the three from the signed total order (<,==,>) and the
+ // three from the unsigned total order. The == cases overlap.
+ // Note: there's a sixth "unordered" outcome for floating-point
+ // comparisons, but we don't use such a beast yet.
+ // These ops are for temporary use by rewrite rules. They
+ // cannot appear in the generated assembly.
+ {name: "FlagEQ"}, // equal
+ {name: "FlagLT_ULT"}, // signed < and unsigned <
+ {name: "FlagLT_UGT"}, // signed < and unsigned >
+ {name: "FlagGT_UGT"}, // signed > and unsigned <
+ {name: "FlagGT_ULT"}, // signed > and unsigned >
+ }
+
+ var AMD64blocks = []blockData{
+ {name: "EQ"},
+ {name: "NE"},
+ {name: "LT"},
+ {name: "LE"},
+ {name: "GT"},
+ {name: "GE"},
+ {name: "ULT"},
+ {name: "ULE"},
+ {name: "UGT"},
+ {name: "UGE"},
+ {name: "EQF"},
+ {name: "NEF"},
+ {name: "ORD"}, // FP, ordered comparison (parity zero)
+ {name: "NAN"}, // FP, unordered comparison (parity one)
+ }
+
+ archs = append(archs, arch{"AMD64", AMD64ops, AMD64blocks, regNamesAMD64})
+}
diff --git a/src/cmd/compile/internal/ssa/gen/README b/src/cmd/compile/internal/ssa/gen/README
new file mode 100644
index 0000000..6731b97
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/README
@@ -0,0 +1,7 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+This package generates opcode tables, rewrite rules, etc. for the ssa compiler.
+Run it with:
+ go run *.go
diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
new file mode 100644
index 0000000..11c7b9d
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -0,0 +1,740 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// values are specified using the following format:
+// (op <type> [auxint] {aux} arg0 arg1 ...)
+// the type and aux fields are optional
+// on the matching side
+// - the type, aux, and auxint fields must match if they are specified.
+// on the generated side
+// - the type of the top-level expression is the same as the one on the left-hand side.
+// - the type of any subexpressions must be specified explicitly.
+// - auxint will be 0 if not specified.
+// - aux will be nil if not specified.
+
+// blocks are specified using the following format:
+// (kind controlvalue succ0 succ1 ...)
+// controlvalue must be "nil" or a value expression
+// succ* fields must be variables
+// For now, the generated successors must be a permutation of the matched successors.
+
+// constant folding
+(Trunc16to8 (Const16 [c])) -> (Const8 [int64(int8(c))])
+(Trunc32to8 (Const32 [c])) -> (Const8 [int64(int8(c))])
+(Trunc32to16 (Const32 [c])) -> (Const16 [int64(int16(c))])
+(Trunc64to8 (Const64 [c])) -> (Const8 [int64(int8(c))])
+(Trunc64to16 (Const64 [c])) -> (Const16 [int64(int16(c))])
+(Trunc64to32 (Const64 [c])) -> (Const32 [int64(int32(c))])
+
+(Neg8 (Const8 [c])) -> (Const8 [-c])
+(Neg16 (Const16 [c])) -> (Const16 [-c])
+(Neg32 (Const32 [c])) -> (Const32 [-c])
+(Neg64 (Const64 [c])) -> (Const64 [-c])
+
+(Add8 (Const8 [c]) (Const8 [d])) -> (Const8 [c+d])
+(Add16 (Const16 [c]) (Const16 [d])) -> (Const16 [c+d])
+(Add32 (Const32 [c]) (Const32 [d])) -> (Const32 [c+d])
+(Add64 (Const64 [c]) (Const64 [d])) -> (Const64 [c+d])
+
+(Sub8 (Const8 [c]) (Const8 [d])) -> (Const8 [c-d])
+(Sub16 (Const16 [c]) (Const16 [d])) -> (Const16 [c-d])
+(Sub32 (Const32 [c]) (Const32 [d])) -> (Const32 [c-d])
+(Sub64 (Const64 [c]) (Const64 [d])) -> (Const64 [c-d])
+
+(Mul8 (Const8 [c]) (Const8 [d])) -> (Const8 [c*d])
+(Mul16 (Const16 [c]) (Const16 [d])) -> (Const16 [c*d])
+(Mul32 (Const32 [c]) (Const32 [d])) -> (Const32 [c*d])
+(Mul64 (Const64 [c]) (Const64 [d])) -> (Const64 [c*d])
+
+(Lsh64x64 (Const64 [c]) (Const64 [d])) -> (Const64 [c << uint64(d)])
+(Rsh64x64 (Const64 [c]) (Const64 [d])) -> (Const64 [c >> uint64(d)])
+(Rsh64Ux64 (Const64 [c]) (Const64 [d])) -> (Const64 [int64(uint64(c) >> uint64(d))])
+(Lsh32x64 (Const32 [c]) (Const64 [d])) -> (Const32 [int64(int32(c) << uint64(d))])
+(Rsh32x64 (Const32 [c]) (Const64 [d])) -> (Const32 [int64(int32(c) >> uint64(d))])
+(Rsh32Ux64 (Const32 [c]) (Const64 [d])) -> (Const32 [int64(uint32(c) >> uint64(d))])
+(Lsh16x64 (Const16 [c]) (Const64 [d])) -> (Const16 [int64(int16(c) << uint64(d))])
+(Rsh16x64 (Const16 [c]) (Const64 [d])) -> (Const16 [int64(int16(c) >> uint64(d))])
+(Rsh16Ux64 (Const16 [c]) (Const64 [d])) -> (Const16 [int64(uint16(c) >> uint64(d))])
+(Lsh8x64 (Const8 [c]) (Const64 [d])) -> (Const8 [int64(int8(c) << uint64(d))])
+(Rsh8x64 (Const8 [c]) (Const64 [d])) -> (Const8 [int64(int8(c) >> uint64(d))])
+(Rsh8Ux64 (Const8 [c]) (Const64 [d])) -> (Const8 [int64(uint8(c) >> uint64(d))])
+
+(Lsh64x64 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64x64 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64Ux64 (Const64 [0]) _) -> (Const64 [0])
+(Lsh32x64 (Const32 [0]) _) -> (Const32 [0])
+(Rsh32x64 (Const32 [0]) _) -> (Const32 [0])
+(Rsh32Ux64 (Const32 [0]) _) -> (Const32 [0])
+(Lsh16x64 (Const16 [0]) _) -> (Const16 [0])
+(Rsh16x64 (Const16 [0]) _) -> (Const16 [0])
+(Rsh16Ux64 (Const16 [0]) _) -> (Const16 [0])
+(Lsh8x64 (Const8 [0]) _) -> (Const8 [0])
+(Rsh8x64 (Const8 [0]) _) -> (Const8 [0])
+(Rsh8Ux64 (Const8 [0]) _) -> (Const8 [0])
+
+(IsInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(inBounds32(c,d))])
+(IsInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(inBounds64(c,d))])
+(IsSliceInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(sliceInBounds32(c,d))])
+(IsSliceInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(sliceInBounds64(c,d))])
+
+(Eq64 x x) -> (ConstBool [1])
+(Eq32 x x) -> (ConstBool [1])
+(Eq16 x x) -> (ConstBool [1])
+(Eq8 x x) -> (ConstBool [1])
+(Eq8 (ConstBool [c]) (ConstBool [d])) -> (ConstBool [b2i((int8(c) != 0) == (int8(d) != 0))])
+(Eq8 (ConstBool [0]) x) -> (Not x)
+(Eq8 (ConstBool [1]) x) -> x
+
+(Neq64 x x) -> (ConstBool [0])
+(Neq32 x x) -> (ConstBool [0])
+(Neq16 x x) -> (ConstBool [0])
+(Neq8 x x) -> (ConstBool [0])
+(Neq8 (ConstBool [c]) (ConstBool [d])) -> (ConstBool [b2i((int8(c) != 0) != (int8(d) != 0))])
+(Neq8 (ConstBool [0]) x) -> x
+(Neq8 (ConstBool [1]) x) -> (Not x)
+
+(Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) -> (Eq64 (Const64 <t> [c-d]) x)
+(Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) -> (Eq32 (Const32 <t> [c-d]) x)
+(Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) -> (Eq16 (Const16 <t> [c-d]) x)
+(Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) -> (Eq8 (Const8 <t> [c-d]) x)
+
+(Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) -> (Neq64 (Const64 <t> [c-d]) x)
+(Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) -> (Neq32 (Const32 <t> [c-d]) x)
+(Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) -> (Neq16 (Const16 <t> [c-d]) x)
+(Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) -> (Neq8 (Const8 <t> [c-d]) x)
+
+// canonicalize: swap arguments for commutative operations when one argument is a constant.
+(Eq64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Eq64 (Const64 <t> [c]) x)
+(Eq32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Eq32 (Const32 <t> [c]) x)
+(Eq16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Eq16 (Const16 <t> [c]) x)
+(Eq8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Eq8 (Const8 <t> [c]) x)
+(Eq8 x (ConstBool <t> [c])) && x.Op != OpConstBool -> (Eq8 (ConstBool <t> [c]) x)
+
+(Neq64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Neq64 (Const64 <t> [c]) x)
+(Neq32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Neq32 (Const32 <t> [c]) x)
+(Neq16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Neq16 (Const16 <t> [c]) x)
+(Neq8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Neq8 (Const8 <t> [c]) x)
+(Neq8 x (ConstBool <t> [c])) && x.Op != OpConstBool -> (Neq8 (ConstBool <t> [c]) x)
+
+(Add64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Add64 (Const64 <t> [c]) x)
+(Add32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Add32 (Const32 <t> [c]) x)
+(Add16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Add16 (Const16 <t> [c]) x)
+(Add8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Add8 (Const8 <t> [c]) x)
+
+(Mul64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Mul64 (Const64 <t> [c]) x)
+(Mul32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Mul32 (Const32 <t> [c]) x)
+(Mul16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Mul16 (Const16 <t> [c]) x)
+(Mul8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Mul8 (Const8 <t> [c]) x)
+
+(Sub64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Add64 (Const64 <t> [-c]) x)
+(Sub32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Add32 (Const32 <t> [-c]) x)
+(Sub16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Add16 (Const16 <t> [-c]) x)
+(Sub8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Add8 (Const8 <t> [-c]) x)
+
+(And64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (And64 (Const64 <t> [c]) x)
+(And32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (And32 (Const32 <t> [c]) x)
+(And16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (And16 (Const16 <t> [c]) x)
+(And8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (And8 (Const8 <t> [c]) x)
+
+(Or64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Or64 (Const64 <t> [c]) x)
+(Or32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Or32 (Const32 <t> [c]) x)
+(Or16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Or16 (Const16 <t> [c]) x)
+(Or8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Or8 (Const8 <t> [c]) x)
+
+(Xor64 x (Const64 <t> [c])) && x.Op != OpConst64 -> (Xor64 (Const64 <t> [c]) x)
+(Xor32 x (Const32 <t> [c])) && x.Op != OpConst32 -> (Xor32 (Const32 <t> [c]) x)
+(Xor16 x (Const16 <t> [c])) && x.Op != OpConst16 -> (Xor16 (Const16 <t> [c]) x)
+(Xor8 x (Const8 <t> [c])) && x.Op != OpConst8 -> (Xor8 (Const8 <t> [c]) x)
+
+// Distribute multiplication c * (d+x) -> c*d + c*x. Useful for:
+// a[i].b = ...; a[i+1].b = ...
+(Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x)) -> (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
+(Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x)) -> (Add32 (Const32 <t> [c*d]) (Mul32 <t> (Const32 <t> [c]) x))
+
+// rewrite shifts of 8/16/32 bit consts into 64 bit consts to reduce
+// the number of the other rewrite rules for const shifts
+(Lsh64x32 <t> x (Const32 [c])) -> (Lsh64x64 x (Const64 <t> [int64(uint32(c))]))
+(Lsh64x16 <t> x (Const16 [c])) -> (Lsh64x64 x (Const64 <t> [int64(uint16(c))]))
+(Lsh64x8 <t> x (Const8 [c])) -> (Lsh64x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh64x32 <t> x (Const32 [c])) -> (Rsh64x64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh64x16 <t> x (Const16 [c])) -> (Rsh64x64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh64x8 <t> x (Const8 [c])) -> (Rsh64x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh64Ux32 <t> x (Const32 [c])) -> (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh64Ux16 <t> x (Const16 [c])) -> (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh64Ux8 <t> x (Const8 [c])) -> (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))]))
+
+(Lsh32x32 <t> x (Const32 [c])) -> (Lsh32x64 x (Const64 <t> [int64(uint32(c))]))
+(Lsh32x16 <t> x (Const16 [c])) -> (Lsh32x64 x (Const64 <t> [int64(uint16(c))]))
+(Lsh32x8 <t> x (Const8 [c])) -> (Lsh32x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh32x32 <t> x (Const32 [c])) -> (Rsh32x64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh32x16 <t> x (Const16 [c])) -> (Rsh32x64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh32x8 <t> x (Const8 [c])) -> (Rsh32x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh32Ux32 <t> x (Const32 [c])) -> (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh32Ux16 <t> x (Const16 [c])) -> (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh32Ux8 <t> x (Const8 [c])) -> (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))]))
+
+(Lsh16x32 <t> x (Const32 [c])) -> (Lsh16x64 x (Const64 <t> [int64(uint32(c))]))
+(Lsh16x16 <t> x (Const16 [c])) -> (Lsh16x64 x (Const64 <t> [int64(uint16(c))]))
+(Lsh16x8 <t> x (Const8 [c])) -> (Lsh16x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh16x32 <t> x (Const32 [c])) -> (Rsh16x64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh16x16 <t> x (Const16 [c])) -> (Rsh16x64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh16x8 <t> x (Const8 [c])) -> (Rsh16x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh16Ux32 <t> x (Const32 [c])) -> (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh16Ux16 <t> x (Const16 [c])) -> (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh16Ux8 <t> x (Const8 [c])) -> (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))]))
+
+(Lsh8x32 <t> x (Const32 [c])) -> (Lsh8x64 x (Const64 <t> [int64(uint32(c))]))
+(Lsh8x16 <t> x (Const16 [c])) -> (Lsh8x64 x (Const64 <t> [int64(uint16(c))]))
+(Lsh8x8 <t> x (Const8 [c])) -> (Lsh8x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh8x32 <t> x (Const32 [c])) -> (Rsh8x64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh8x16 <t> x (Const16 [c])) -> (Rsh8x64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh8x8 <t> x (Const8 [c])) -> (Rsh8x64 x (Const64 <t> [int64(uint8(c))]))
+(Rsh8Ux32 <t> x (Const32 [c])) -> (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))]))
+(Rsh8Ux16 <t> x (Const16 [c])) -> (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))]))
+(Rsh8Ux8 <t> x (Const8 [c])) -> (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))]))
+
+// shifts by zero
+(Lsh64x64 x (Const64 [0])) -> x
+(Rsh64x64 x (Const64 [0])) -> x
+(Rsh64Ux64 x (Const64 [0])) -> x
+(Lsh32x64 x (Const64 [0])) -> x
+(Rsh32x64 x (Const64 [0])) -> x
+(Rsh32Ux64 x (Const64 [0])) -> x
+(Lsh16x64 x (Const64 [0])) -> x
+(Rsh16x64 x (Const64 [0])) -> x
+(Rsh16Ux64 x (Const64 [0])) -> x
+(Lsh8x64 x (Const64 [0])) -> x
+(Rsh8x64 x (Const64 [0])) -> x
+(Rsh8Ux64 x (Const64 [0])) -> x
+
+// zero shifted.
+// TODO: other bit sizes.
+(Lsh64x64 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64x64 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64Ux64 (Const64 [0]) _) -> (Const64 [0])
+(Lsh64x32 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64x32 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64Ux32 (Const64 [0]) _) -> (Const64 [0])
+(Lsh64x16 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64x16 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64Ux16 (Const64 [0]) _) -> (Const64 [0])
+(Lsh64x8 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64x8 (Const64 [0]) _) -> (Const64 [0])
+(Rsh64Ux8 (Const64 [0]) _) -> (Const64 [0])
+
+// large left shifts of all values, and right shifts of unsigned values
+(Lsh64x64 _ (Const64 [c])) && uint64(c) >= 64 -> (Const64 [0])
+(Rsh64Ux64 _ (Const64 [c])) && uint64(c) >= 64 -> (Const64 [0])
+(Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0])
+(Rsh32Ux64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0])
+(Lsh16x64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const16 [0])
+(Rsh16Ux64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const16 [0])
+(Lsh8x64 _ (Const64 [c])) && uint64(c) >= 8 -> (Const8 [0])
+(Rsh8Ux64 _ (Const64 [c])) && uint64(c) >= 8 -> (Const8 [0])
+
+
+// combine const shifts
+(Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh64x64 x (Const64 <t> [c+d]))
+(Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh32x64 x (Const64 <t> [c+d]))
+(Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh16x64 x (Const64 <t> [c+d]))
+(Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh8x64 x (Const64 <t> [c+d]))
+
+(Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh64x64 x (Const64 <t> [c+d]))
+(Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh32x64 x (Const64 <t> [c+d]))
+(Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh16x64 x (Const64 <t> [c+d]))
+(Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh8x64 x (Const64 <t> [c+d]))
+
+(Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh64Ux64 x (Const64 <t> [c+d]))
+(Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh32Ux64 x (Const64 <t> [c+d]))
+(Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh16Ux64 x (Const64 <t> [c+d]))
+(Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh8Ux64 x (Const64 <t> [c+d]))
+
+// constant comparisons
+(Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) == int64(d))])
+(Eq32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) == int32(d))])
+(Eq16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) == int16(d))])
+(Eq8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) == int8(d))])
+
+(Neq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) != int64(d))])
+(Neq32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) != int32(d))])
+(Neq16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) != int16(d))])
+(Neq8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) != int8(d))])
+
+(Greater64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) > int64(d))])
+(Greater32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) > int32(d))])
+(Greater16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) > int16(d))])
+(Greater8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) > int8(d))])
+
+(Greater64U (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(uint64(c) > uint64(d))])
+(Greater32U (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(uint32(c) > uint32(d))])
+(Greater16U (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(uint16(c) > uint16(d))])
+(Greater8U (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(uint8(c) > uint8(d))])
+
+(Geq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) >= int64(d))])
+(Geq32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) >= int32(d))])
+(Geq16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) >= int16(d))])
+(Geq8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) >= int8(d))])
+
+(Geq64U (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(uint64(c) >= uint64(d))])
+(Geq32U (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(uint32(c) >= uint32(d))])
+(Geq16U (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(uint16(c) >= uint16(d))])
+(Geq8U (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(uint8(c) >= uint8(d))])
+
+(Less64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) < int64(d))])
+(Less32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) < int32(d))])
+(Less16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) < int16(d))])
+(Less8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) < int8(d))])
+
+(Less64U (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(uint64(c) < uint64(d))])
+(Less32U (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(uint32(c) < uint32(d))])
+(Less16U (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(uint16(c) < uint16(d))])
+(Less8U (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(uint8(c) < uint8(d))])
+
+(Leq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) <= int64(d))])
+(Leq32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) <= int32(d))])
+(Leq16 (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(int16(c) <= int16(d))])
+(Leq8 (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(int8(c) <= int8(d))])
+
+(Leq64U (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(uint64(c) <= uint64(d))])
+(Leq32U (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(uint32(c) <= uint32(d))])
+(Leq16U (Const16 [c]) (Const16 [d])) -> (ConstBool [b2i(uint16(c) <= uint16(d))])
+(Leq8U (Const8 [c]) (Const8 [d])) -> (ConstBool [b2i(uint8(c) <= uint8(d))])
+
+// simplifications
+(Or64 x x) -> x
+(Or32 x x) -> x
+(Or16 x x) -> x
+(Or8 x x) -> x
+(Or64 (Const64 [0]) x) -> x
+(Or32 (Const32 [0]) x) -> x
+(Or16 (Const16 [0]) x) -> x
+(Or8 (Const8 [0]) x) -> x
+(Or64 (Const64 [-1]) _) -> (Const64 [-1])
+(Or32 (Const32 [-1]) _) -> (Const32 [-1])
+(Or16 (Const16 [-1]) _) -> (Const16 [-1])
+(Or8 (Const8 [-1]) _) -> (Const8 [-1])
+(And64 x x) -> x
+(And32 x x) -> x
+(And16 x x) -> x
+(And8 x x) -> x
+(And64 (Const64 [-1]) x) -> x
+(And32 (Const32 [-1]) x) -> x
+(And16 (Const16 [-1]) x) -> x
+(And8 (Const8 [-1]) x) -> x
+(And64 (Const64 [0]) _) -> (Const64 [0])
+(And32 (Const32 [0]) _) -> (Const32 [0])
+(And16 (Const16 [0]) _) -> (Const16 [0])
+(And8 (Const8 [0]) _) -> (Const8 [0])
+(Xor64 x x) -> (Const64 [0])
+(Xor32 x x) -> (Const32 [0])
+(Xor16 x x) -> (Const16 [0])
+(Xor8 x x) -> (Const8 [0])
+(Xor64 (Const64 [0]) x) -> x
+(Xor32 (Const32 [0]) x) -> x
+(Xor16 (Const16 [0]) x) -> x
+(Xor8 (Const8 [0]) x) -> x
+(Add64 (Const64 [0]) x) -> x
+(Add32 (Const32 [0]) x) -> x
+(Add16 (Const16 [0]) x) -> x
+(Add8 (Const8 [0]) x) -> x
+(Sub64 x x) -> (Const64 [0])
+(Sub32 x x) -> (Const32 [0])
+(Sub16 x x) -> (Const16 [0])
+(Sub8 x x) -> (Const8 [0])
+(Mul64 (Const64 [0]) _) -> (Const64 [0])
+(Mul32 (Const32 [0]) _) -> (Const32 [0])
+(Mul16 (Const16 [0]) _) -> (Const16 [0])
+(Mul8 (Const8 [0]) _) -> (Const8 [0])
+(Com8 (Com8 x)) -> x
+(Com16 (Com16 x)) -> x
+(Com32 (Com32 x)) -> x
+(Com64 (Com64 x)) -> x
+(Neg8 (Sub8 x y)) -> (Sub8 y x)
+(Neg16 (Sub16 x y)) -> (Sub16 y x)
+(Neg32 (Sub32 x y)) -> (Sub32 y x)
+(Neg64 (Sub64 x y)) -> (Sub64 y x)
+
+// Rewrite AND of consts as shifts if possible, slightly faster for 32/64 bit operands
+// leading zeros can be shifted left, then right
+(And64 <t> (Const64 [y]) x) && nlz(y) + nto(y) == 64 -> (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
+(And32 <t> (Const32 [y]) x) && nlz(int64(int32(y))) + nto(int64(int32(y))) == 64 -> (Rsh32Ux32 (Lsh32x32 <t> x (Const32 <t> [nlz(int64(int32(y)))-32])) (Const32 <t> [nlz(int64(int32(y)))-32]))
+// trailing zeros can be shifted right, then left
+(And64 <t> (Const64 [y]) x) && nlo(y) + ntz(y) == 64 -> (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
+(And32 <t> (Const32 [y]) x) && nlo(int64(int32(y))) + ntz(int64(int32(y))) == 64 -> (Lsh32x32 (Rsh32Ux32 <t> x (Const32 <t> [ntz(int64(int32(y)))])) (Const32 <t> [ntz(int64(int32(y)))]))
+
+// simplifications often used for lengths. e.g. len(s[i:i+5])==5
+(Sub64 (Add64 x y) x) -> y
+(Sub64 (Add64 x y) y) -> x
+(Sub32 (Add32 x y) x) -> y
+(Sub32 (Add32 x y) y) -> x
+(Sub16 (Add16 x y) x) -> y
+(Sub16 (Add16 x y) y) -> x
+(Sub8 (Add8 x y) x) -> y
+(Sub8 (Add8 x y) y) -> x
+
+// basic phi simplifications
+(Phi (Const8 [c]) (Const8 [d])) && int8(c) == int8(d) -> (Const8 [c])
+(Phi (Const16 [c]) (Const16 [d])) && int16(c) == int16(d) -> (Const16 [c])
+(Phi (Const32 [c]) (Const32 [d])) && int32(c) == int32(d) -> (Const32 [c])
+(Phi (Const64 [c]) (Const64 [c])) -> (Const64 [c])
+
+// user nil checks
+(NeqPtr p (ConstNil)) -> (IsNonNil p)
+(NeqPtr (ConstNil) p) -> (IsNonNil p)
+(EqPtr p (ConstNil)) -> (Not (IsNonNil p))
+(EqPtr (ConstNil) p) -> (Not (IsNonNil p))
+
+// slice and interface comparisons
+// The frontend ensures that we can only compare against nil,
+// so we need only compare the first word (interface type or slice ptr).
+(EqInter x y) -> (EqPtr (ITab x) (ITab y))
+(NeqInter x y) -> (NeqPtr (ITab x) (ITab y))
+(EqSlice x y) -> (EqPtr (SlicePtr x) (SlicePtr y))
+(NeqSlice x y) -> (NeqPtr (SlicePtr x) (SlicePtr y))
+
+
+// Load of store of same address, with compatibly typed value and same size
+(Load <t1> p1 (Store [w] p2 x _)) && isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && w == t1.Size() -> x
+
+
+// indexing operations
+// Note: bounds check has already been done
+(ArrayIndex (Load ptr mem) idx) && b == v.Args[0].Block -> (Load (PtrIndex <v.Type.PtrTo()> ptr idx) mem)
+(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <config.fe.TypeInt()> idx (Const32 <config.fe.TypeInt()> [t.Elem().Size()])))
+(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <config.fe.TypeInt()> idx (Const64 <config.fe.TypeInt()> [t.Elem().Size()])))
+
+// struct operations
+(StructSelect (StructMake1 x)) -> x
+(StructSelect [0] (StructMake2 x _)) -> x
+(StructSelect [1] (StructMake2 _ x)) -> x
+(StructSelect [0] (StructMake3 x _ _)) -> x
+(StructSelect [1] (StructMake3 _ x _)) -> x
+(StructSelect [2] (StructMake3 _ _ x)) -> x
+(StructSelect [0] (StructMake4 x _ _ _)) -> x
+(StructSelect [1] (StructMake4 _ x _ _)) -> x
+(StructSelect [2] (StructMake4 _ _ x _)) -> x
+(StructSelect [3] (StructMake4 _ _ _ x)) -> x
+
+(Load <t> _ _) && t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) ->
+ (StructMake0)
+(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) ->
+ (StructMake1
+ (Load <t.FieldType(0)> ptr mem))
+(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) ->
+ (StructMake2
+ (Load <t.FieldType(0)> ptr mem)
+ (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem))
+(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) ->
+ (StructMake3
+ (Load <t.FieldType(0)> ptr mem)
+ (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem)
+ (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem))
+(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) ->
+ (StructMake4
+ (Load <t.FieldType(0)> ptr mem)
+ (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem)
+ (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem)
+ (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem))
+
+(StructSelect [i] (Load <t> ptr mem)) && !config.fe.CanSSA(t) ->
+ @v.Args[0].Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(i)] ptr) mem)
+
+(Store _ (StructMake0) mem) -> mem
+(Store dst (StructMake1 <t> f0) mem) ->
+ (Store [t.FieldType(0).Size()] dst f0 mem)
+(Store dst (StructMake2 <t> f0 f1) mem) ->
+ (Store [t.FieldType(1).Size()]
+ (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
+ f1
+ (Store [t.FieldType(0).Size()] dst f0 mem))
+(Store dst (StructMake3 <t> f0 f1 f2) mem) ->
+ (Store [t.FieldType(2).Size()]
+ (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst)
+ f2
+ (Store [t.FieldType(1).Size()]
+ (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
+ f1
+ (Store [t.FieldType(0).Size()] dst f0 mem)))
+(Store dst (StructMake4 <t> f0 f1 f2 f3) mem) ->
+ (Store [t.FieldType(3).Size()]
+ (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst)
+ f3
+ (Store [t.FieldType(2).Size()]
+ (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst)
+ f2
+ (Store [t.FieldType(1).Size()]
+ (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
+ f1
+ (Store [t.FieldType(0).Size()] dst f0 mem))))
+
+// complex ops
+(ComplexReal (ComplexMake real _ )) -> real
+(ComplexImag (ComplexMake _ imag )) -> imag
+
+(Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 ->
+ (ComplexMake
+ (Load <config.fe.TypeFloat32()> ptr mem)
+ (Load <config.fe.TypeFloat32()>
+ (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr)
+ mem)
+ )
+(Store [8] dst (ComplexMake real imag) mem) ->
+ (Store [4]
+ (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst)
+ imag
+ (Store [4] dst real mem))
+
+(Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 ->
+ (ComplexMake
+ (Load <config.fe.TypeFloat64()> ptr mem)
+ (Load <config.fe.TypeFloat64()>
+ (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr)
+ mem)
+ )
+(Store [16] dst (ComplexMake real imag) mem) ->
+ (Store [8]
+ (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst)
+ imag
+ (Store [8] dst real mem))
+
+// string ops
+(StringPtr (StringMake ptr _)) -> ptr
+(StringLen (StringMake _ len)) -> len
+(ConstString {s}) && config.PtrSize == 4 && s.(string) == "" ->
+ (StringMake (ConstNil) (Const32 <config.fe.TypeInt()> [0]))
+(ConstString {s}) && config.PtrSize == 8 && s.(string) == "" ->
+ (StringMake (ConstNil) (Const64 <config.fe.TypeInt()> [0]))
+(ConstString {s}) && config.PtrSize == 4 && s.(string) != "" ->
+ (StringMake
+ (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))}
+ (SB))
+ (Const32 <config.fe.TypeInt()> [int64(len(s.(string)))]))
+(ConstString {s}) && config.PtrSize == 8 && s.(string) != "" ->
+ (StringMake
+ (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))}
+ (SB))
+ (Const64 <config.fe.TypeInt()> [int64(len(s.(string)))]))
+(Load <t> ptr mem) && t.IsString() ->
+ (StringMake
+ (Load <config.fe.TypeBytePtr()> ptr mem)
+ (Load <config.fe.TypeInt()>
+ (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr)
+ mem))
+(Store [2*config.PtrSize] dst (StringMake ptr len) mem) ->
+ (Store [config.PtrSize]
+ (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst)
+ len
+ (Store [config.PtrSize] dst ptr mem))
+
+// slice ops
+(SlicePtr (SliceMake ptr _ _ )) -> ptr
+(SliceLen (SliceMake _ len _)) -> len
+(SliceCap (SliceMake _ _ cap)) -> cap
+(ConstSlice) && config.PtrSize == 4 ->
+ (SliceMake
+ (ConstNil <config.fe.TypeBytePtr()>)
+ (Const32 <config.fe.TypeInt()> [0])
+ (Const32 <config.fe.TypeInt()> [0]))
+(ConstSlice) && config.PtrSize == 8 ->
+ (SliceMake
+ (ConstNil <config.fe.TypeBytePtr()>)
+ (Const64 <config.fe.TypeInt()> [0])
+ (Const64 <config.fe.TypeInt()> [0]))
+
+(Load <t> ptr mem) && t.IsSlice() ->
+ (SliceMake
+ (Load <config.fe.TypeBytePtr()> ptr mem)
+ (Load <config.fe.TypeInt()>
+ (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr)
+ mem)
+ (Load <config.fe.TypeInt()>
+ (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr)
+ mem))
+(Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) ->
+ (Store [config.PtrSize]
+ (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst)
+ cap
+ (Store [config.PtrSize]
+ (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst)
+ len
+ (Store [config.PtrSize] dst ptr mem)))
+
+// interface ops
+(ITab (IMake itab _)) -> itab
+(IData (IMake _ data)) -> data
+(ConstInterface) ->
+ (IMake
+ (ConstNil <config.fe.TypeBytePtr()>)
+ (ConstNil <config.fe.TypeBytePtr()>))
+(Load <t> ptr mem) && t.IsInterface() ->
+ (IMake
+ (Load <config.fe.TypeBytePtr()> ptr mem)
+ (Load <config.fe.TypeBytePtr()>
+ (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr)
+ mem))
+(Store [2*config.PtrSize] dst (IMake itab data) mem) ->
+ (Store [config.PtrSize]
+ (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst)
+ data
+ (Store [config.PtrSize] dst itab mem))
+
+// un-SSAable values use mem->mem copies
+(Store [size] dst (Load <t> src mem) mem) && !config.fe.CanSSA(t) -> (Move [size] dst src mem)
+(Store [size] dst (Load <t> src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t) -> (Move [size] dst src (VarDef {x} mem))
+
+(Check (NilCheck (GetG _) _) next) -> (Plain nil next)
+
+(If (Not cond) yes no) -> (If cond no yes)
+(If (ConstBool [c]) yes no) && c == 1 -> (First nil yes no)
+(If (ConstBool [c]) yes no) && c == 0 -> (First nil no yes)
+
+// Get rid of Convert ops for pointer arithmetic on unsafe.Pointer.
+(Convert (Add64 (Convert ptr mem) off) mem) -> (Add64 ptr off)
+(Convert (Add64 off (Convert ptr mem)) mem) -> (Add64 ptr off)
+(Convert (Convert ptr mem) mem) -> ptr
+
+// Decompose compound argument values
+(Arg {n} [off]) && v.Type.IsString() ->
+ (StringMake
+ (Arg <config.fe.TypeBytePtr()> {n} [off])
+ (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]))
+
+(Arg {n} [off]) && v.Type.IsSlice() ->
+ (SliceMake
+ (Arg <config.fe.TypeBytePtr()> {n} [off])
+ (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize])
+ (Arg <config.fe.TypeInt()> {n} [off+2*config.PtrSize]))
+
+(Arg {n} [off]) && v.Type.IsInterface() ->
+ (IMake
+ (Arg <config.fe.TypeBytePtr()> {n} [off])
+ (Arg <config.fe.TypeBytePtr()> {n} [off+config.PtrSize]))
+
+(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 ->
+ (ComplexMake
+ (Arg <config.fe.TypeFloat64()> {n} [off])
+ (Arg <config.fe.TypeFloat64()> {n} [off+8]))
+
+(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 ->
+ (ComplexMake
+ (Arg <config.fe.TypeFloat32()> {n} [off])
+ (Arg <config.fe.TypeFloat32()> {n} [off+4]))
+
+(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) ->
+ (StructMake0)
+(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) ->
+ (StructMake1
+ (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]))
+(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) ->
+ (StructMake2
+ (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])
+ (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]))
+(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) ->
+ (StructMake3
+ (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])
+ (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)])
+ (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]))
+(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) ->
+ (StructMake4
+ (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])
+ (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)])
+ (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)])
+ (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)]))
+
+// strength reduction of divide by a constant.
+// Note: frontend does <=32 bits. We only need to do 64 bits here.
+// TODO: Do them all here?
+
+// Div/mod by 1. Currently handled by frontend.
+//(Div64 n (Const64 [1])) -> n
+//(Div64u n (Const64 [1])) -> n
+//(Mod64 n (Const64 [1])) -> (Const64 [0])
+//(Mod64u n (Const64 [1])) -> (Const64 [0])
+
+// Unsigned divide by power of 2. Currently handled by frontend.
+//(Div64u <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <t> [log2(c)]))
+//(Mod64u <t> n (Const64 [c])) && isPowerOfTwo(c) -> (And64 n (Const64 <t> [c-1]))
+
+// Signed divide by power of 2. Currently handled by frontend.
+// n / c = n >> log(c) if n >= 0
+// = (n+c-1) >> log(c) if n < 0
+// We conditionally add c-1 by adding n>>63>>(64-log(c)) (first shift signed, second shift unsigned).
+//(Div64 <t> n (Const64 [c])) && isPowerOfTwo(c) ->
+// (Rsh64x64
+// (Add64 <t>
+// n
+// (Rsh64Ux64 <t>
+// (Rsh64x64 <t> n (Const64 <t> [63]))
+// (Const64 <t> [64-log2(c)])))
+// (Const64 <t> [log2(c)]))
+
+// Unsigned divide, not a power of 2. Strength reduce to a multiply.
+(Div64u <t> x (Const64 [c])) && umagic64ok(c) && !umagic64a(c) ->
+ (Rsh64Ux64
+ (Hmul64u <t>
+ (Const64 <t> [umagic64m(c)])
+ x)
+ (Const64 <t> [umagic64s(c)]))
+(Div64u <t> x (Const64 [c])) && umagic64ok(c) && umagic64a(c) ->
+ (Rsh64Ux64
+ (Avg64u <t>
+ (Hmul64u <t>
+ x
+ (Const64 <t> [umagic64m(c)]))
+ x)
+ (Const64 <t> [umagic64s(c)-1]))
+
+// Signed divide, not a power of 2. Strength reduce to a multiply.
+(Div64 <t> x (Const64 [c])) && c > 0 && smagic64ok(c) && smagic64m(c) > 0 ->
+ (Sub64 <t>
+ (Rsh64x64 <t>
+ (Hmul64 <t>
+ (Const64 <t> [smagic64m(c)])
+ x)
+ (Const64 <t> [smagic64s(c)]))
+ (Rsh64x64 <t>
+ x
+ (Const64 <t> [63])))
+(Div64 <t> x (Const64 [c])) && c > 0 && smagic64ok(c) && smagic64m(c) < 0 ->
+ (Sub64 <t>
+ (Rsh64x64 <t>
+ (Add64 <t>
+ (Hmul64 <t>
+ (Const64 <t> [smagic64m(c)])
+ x)
+ x)
+ (Const64 <t> [smagic64s(c)]))
+ (Rsh64x64 <t>
+ x
+ (Const64 <t> [63])))
+(Div64 <t> x (Const64 [c])) && c < 0 && smagic64ok(c) && smagic64m(c) > 0 ->
+ (Neg64 <t>
+ (Sub64 <t>
+ (Rsh64x64 <t>
+ (Hmul64 <t>
+ (Const64 <t> [smagic64m(c)])
+ x)
+ (Const64 <t> [smagic64s(c)]))
+ (Rsh64x64 <t>
+ x
+ (Const64 <t> [63]))))
+(Div64 <t> x (Const64 [c])) && c < 0 && smagic64ok(c) && smagic64m(c) < 0 ->
+ (Neg64 <t>
+ (Sub64 <t>
+ (Rsh64x64 <t>
+ (Add64 <t>
+ (Hmul64 <t>
+ (Const64 <t> [smagic64m(c)])
+ x)
+ x)
+ (Const64 <t> [smagic64s(c)]))
+ (Rsh64x64 <t>
+ x
+ (Const64 <t> [63]))))
+
+// A%B = A-(A/B*B).
+// This implements % with two * and a bunch of ancillary ops.
+// One of the * is free if the user's code also computes A/B.
+(Mod64 <t> x (Const64 [c])) && smagic64ok(c) -> (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c])))
+(Mod64u <t> x (Const64 [c])) && umagic64ok(c) -> (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c])))
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
new file mode 100644
index 0000000..31e45c4
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -0,0 +1,416 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+var genericOps = []opData{
+ // 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", 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", 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", 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", argLength: 2}, // arg0 / arg1
+ {name: "Div64F", argLength: 2},
+
+ {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", argLength: 2}, // (uint64(arg0) + uint64(arg1)) / 2, correct to all 64 bits.
+
+ {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", 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", 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", 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", 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", 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", 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", 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))
+ // where A is the bit width of arg0 and result.
+ // Note that because rotates are pattern-matched from
+ // shifts, that a rotate of arg1=A+k (k > 0) bits originated from
+ // (arg0 << A+k) ^ (arg0 >> -k) =
+ // 0 ^ arg0>>huge_unsigned =
+ // 0 ^ 0 = 0
+ // which is not the same as a rotation by A+k
+ //
+ // However, in the specific case of k = 0, the result of
+ // the shift idiom is the same as the result for the
+ // rotate idiom, i.e., result=arg0.
+ // This is different from shifts, where
+ // arg0 << A is defined to be zero.
+ //
+ // Because of this, and also because the primary use case
+ // 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", 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", 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", 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", 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", 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", 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", 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", argLength: 1}, // !arg0
+
+ {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", argLength: 1}, // ^arg0
+ {name: "Com16", argLength: 1},
+ {name: "Com32", argLength: 1},
+ {name: "Com64", argLength: 1},
+
+ {name: "Sqrt", argLength: 1}, // sqrt(arg0), float64 only
+
+ // 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", argLength: 2},
+
+ // constants. Constant values are stored in the aux or
+ // auxint fields.
+ {name: "ConstBool", aux: "Bool"}, // auxint is 0 for false and 1 for true
+ {name: "ConstString", aux: "String"}, // value is aux.(string)
+ {name: "ConstNil", typ: "BytePtr"}, // nil pointer
+ {name: "Const8", aux: "Int8"}, // value is low 8 bits of auxint
+ {name: "Const16", aux: "Int16"}, // value is low 16 bits of auxint
+ {name: "Const32", aux: "Int32"}, // value is low 32 bits of auxint
+ {name: "Const64", aux: "Int64"}, // value is auxint
+ {name: "Const32F", aux: "Float"}, // value is math.Float64frombits(uint64(auxint))
+ {name: "Const64F", aux: "Float"}, // value is math.Float64frombits(uint64(auxint))
+ {name: "ConstInterface"}, // nil interface
+ {name: "ConstSlice"}, // nil slice
+
+ // Constant-like things
+ {name: "InitMem"}, // memory input to the function.
+ {name: "Arg", aux: "SymOff"}, // argument to the function. aux=GCNode of arg, off = offset in that arg.
+
+ // The address of a variable. arg0 is the base pointer (SB or SP, depending
+ // 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", 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", 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", 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", 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", 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", 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", argLength: 1}, // runtime.getg() (read g pointer). arg0=mem
+ {name: "GetClosurePtr"}, // get closure pointer from dedicated register
+
+ // Indexing operations
+ {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", 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", argLength: 2}, // arg0=real, arg1=imag
+ {name: "ComplexReal", argLength: 1}, // real(arg0)
+ {name: "ComplexImag", argLength: 1}, // imag(arg0)
+
+ // Strings
+ {name: "StringMake", argLength: 2}, // arg0=ptr, arg1=len
+ {name: "StringPtr", argLength: 1}, // ptr(arg0)
+ {name: "StringLen", argLength: 1}, // len(arg0)
+
+ // Interfaces
+ {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", 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", argLength: 1},
+ {name: "LoadReg", argLength: 1},
+
+ // Used during ssa construction. Like Copy, but the arg has not been specified yet.
+ {name: "FwdRef"},
+
+ // Unknown value. Used for Values whose values don't matter because they are dead code.
+ {name: "Unknown"},
+
+ {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
+// ----------------------------------------------------------
+// Exit return mem [] yes
+// Ret return mem [] yes
+// RetJmp return mem [] yes
+// Plain nil [next]
+// If a boolean Value [then, else]
+// Call mem [next] yes (control opcode should be OpCall or OpStaticCall)
+// Check void [next] yes (control opcode should be Op{Lowered}NilCheck)
+// First nil [always,never]
+
+var genericBlocks = []blockData{
+ {name: "Plain"}, // a single successor
+ {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1]
+ {name: "Call"}, // 1 successor, control is call op (of memory type)
+ {name: "Check"}, // 1 successor, control is nilcheck op (of void type)
+ {name: "Ret"}, // no successors, control value is memory result
+ {name: "RetJmp"}, // no successors, jumps to b.Aux.(*gc.Sym)
+ {name: "Exit"}, // no successors, control value generates a panic
+
+ // transient block states used for dead code removal
+ {name: "First"}, // 2 successors, always takes the first one (second is dead)
+ {name: "Dead"}, // no successors; determined to be dead but not yet removed
+}
+
+func init() {
+ archs = append(archs, arch{"generic", genericOps, genericBlocks, nil})
+}
diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
new file mode 100644
index 0000000..660511e
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -0,0 +1,262 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The gen command generates Go code (in the parent directory) for all
+// the architecture-specific opcodes, blocks, and rewrites.
+
+package main
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "go/format"
+ "io/ioutil"
+ "log"
+ "regexp"
+ "sort"
+)
+
+type arch struct {
+ name string
+ ops []opData
+ blocks []blockData
+ regnames []string
+}
+
+type opData struct {
+ name string
+ reg regInfo
+ asm string
+ typ string // default result type
+ aux string
+ rematerializeable bool
+ argLength int32 // number of arguments, if -1, then this operation has a variable number of arguments
+ commutative bool // this operation is commutative (e.g. addition)
+}
+
+type blockData struct {
+ name string
+}
+
+type regInfo struct {
+ inputs []regMask
+ clobbers regMask
+ outputs []regMask
+}
+
+type regMask uint64
+
+func (a arch) regMaskComment(r regMask) string {
+ var buf bytes.Buffer
+ for i := uint64(0); r != 0; i++ {
+ if r&1 != 0 {
+ if buf.Len() == 0 {
+ buf.WriteString(" //")
+ }
+ buf.WriteString(" ")
+ buf.WriteString(a.regnames[i])
+ }
+ r >>= 1
+ }
+ return buf.String()
+}
+
+var archs []arch
+
+func main() {
+ flag.Parse()
+ genOp()
+ genLower()
+}
+
+func genOp() {
+ w := new(bytes.Buffer)
+ fmt.Fprintf(w, "// autogenerated: do not edit!\n")
+ fmt.Fprintf(w, "// generated from gen/*Ops.go\n")
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "package ssa")
+
+ fmt.Fprintln(w, "import \"cmd/internal/obj/x86\"")
+
+ // generate Block* declarations
+ fmt.Fprintln(w, "const (")
+ fmt.Fprintln(w, "BlockInvalid BlockKind = iota")
+ for _, a := range archs {
+ fmt.Fprintln(w)
+ for _, d := range a.blocks {
+ fmt.Fprintf(w, "Block%s%s\n", a.Name(), d.name)
+ }
+ }
+ fmt.Fprintln(w, ")")
+
+ // generate block kind string method
+ fmt.Fprintln(w, "var blockString = [...]string{")
+ fmt.Fprintln(w, "BlockInvalid:\"BlockInvalid\",")
+ for _, a := range archs {
+ fmt.Fprintln(w)
+ for _, b := range a.blocks {
+ fmt.Fprintf(w, "Block%s%s:\"%s\",\n", a.Name(), b.name, b.name)
+ }
+ }
+ fmt.Fprintln(w, "}")
+ fmt.Fprintln(w, "func (k BlockKind) String() string {return blockString[k]}")
+
+ // generate Op* declarations
+ fmt.Fprintln(w, "const (")
+ fmt.Fprintln(w, "OpInvalid Op = iota")
+ for _, a := range archs {
+ fmt.Fprintln(w)
+ for _, v := range a.ops {
+ fmt.Fprintf(w, "Op%s%s\n", a.Name(), v.name)
+ }
+ }
+ fmt.Fprintln(w, ")")
+
+ // generate OpInfo table
+ fmt.Fprintln(w, "var opcodeTable = [...]opInfo{")
+ fmt.Fprintln(w, " { name: \"OpInvalid\" },")
+ for _, a := range archs {
+ fmt.Fprintln(w)
+ for _, v := range a.ops {
+ fmt.Fprintln(w, "{")
+ fmt.Fprintf(w, "name:\"%s\",\n", v.name)
+
+ // flags
+ if v.aux != "" {
+ fmt.Fprintf(w, "auxType: aux%s,\n", v.aux)
+ }
+ fmt.Fprintf(w, "argLen: %d,\n", v.argLength)
+
+ if v.rematerializeable {
+ if v.reg.clobbers != 0 {
+ log.Fatalf("%s is rematerializeable and clobbers registers", v.name)
+ }
+ fmt.Fprintln(w, "rematerializeable: true,")
+ }
+ if v.commutative {
+ fmt.Fprintln(w, "commutative: true,")
+ }
+ if a.name == "generic" {
+ fmt.Fprintln(w, "generic:true,")
+ fmt.Fprintln(w, "},") // close op
+ // generic ops have no reg info or asm
+ continue
+ }
+ if v.asm != "" {
+ fmt.Fprintf(w, "asm: x86.A%s,\n", v.asm)
+ }
+ fmt.Fprintln(w, "reg:regInfo{")
+
+ // Compute input allocation order. We allocate from the
+ // most to the least constrained input. This order guarantees
+ // that we will always be able to find a register.
+ var s []intPair
+ for i, r := range v.reg.inputs {
+ if r != 0 {
+ s = append(s, intPair{countRegs(r), i})
+ }
+ }
+ if len(s) > 0 {
+ sort.Sort(byKey(s))
+ fmt.Fprintln(w, "inputs: []inputInfo{")
+ for _, p := range s {
+ r := v.reg.inputs[p.val]
+ fmt.Fprintf(w, "{%d,%d},%s\n", p.val, r, a.regMaskComment(r))
+ }
+ fmt.Fprintln(w, "},")
+ }
+ if v.reg.clobbers > 0 {
+ fmt.Fprintf(w, "clobbers: %d,%s\n", v.reg.clobbers, a.regMaskComment(v.reg.clobbers))
+ }
+ // reg outputs
+ if len(v.reg.outputs) > 0 {
+ fmt.Fprintln(w, "outputs: []regMask{")
+ for _, r := range v.reg.outputs {
+ fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r))
+ }
+ fmt.Fprintln(w, "},")
+ }
+ fmt.Fprintln(w, "},") // close reg info
+ fmt.Fprintln(w, "},") // close op
+ }
+ }
+ fmt.Fprintln(w, "}")
+
+ fmt.Fprintln(w, "func (o Op) Asm() int {return opcodeTable[o].asm}")
+
+ // generate op string method
+ fmt.Fprintln(w, "func (o Op) String() string {return opcodeTable[o].name }")
+
+ // gofmt result
+ b := w.Bytes()
+ var err error
+ b, err = format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", w.Bytes())
+ panic(err)
+ }
+
+ err = ioutil.WriteFile("../opGen.go", b, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+
+ // Check that ../gc/ssa.go handles all the arch-specific opcodes.
+ // This is very much a hack, but it is better than nothing.
+ ssa, err := ioutil.ReadFile("../../gc/ssa.go")
+ if err != nil {
+ log.Fatalf("can't read ../../gc/ssa.go: %v", err)
+ }
+ for _, a := range archs {
+ if a.name == "generic" {
+ continue
+ }
+ for _, v := range a.ops {
+ pattern := fmt.Sprintf("\\Wssa[.]Op%s%s\\W", a.name, v.name)
+ match, err := regexp.Match(pattern, ssa)
+ if err != nil {
+ log.Fatalf("bad opcode regexp %s: %v", pattern, err)
+ }
+ if !match {
+ log.Fatalf("Op%s%s has no code generation in ../../gc/ssa.go", a.name, v.name)
+ }
+ }
+ }
+}
+
+// Name returns the name of the architecture for use in Op* and Block* enumerations.
+func (a arch) Name() string {
+ s := a.name
+ if s == "generic" {
+ s = ""
+ }
+ return s
+}
+
+func genLower() {
+ for _, a := range archs {
+ genRules(a)
+ }
+}
+
+// countRegs returns the number of set bits in the register mask.
+func countRegs(r regMask) int {
+ n := 0
+ for r != 0 {
+ n += int(r & 1)
+ r >>= 1
+ }
+ return n
+}
+
+// for sorting a pair of integers by key
+type intPair struct {
+ key, val int
+}
+type byKey []intPair
+
+func (a byKey) Len() int { return len(a) }
+func (a byKey) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byKey) Less(i, j int) bool { return a[i].key < a[j].key }
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
new file mode 100644
index 0000000..e3e3efa
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -0,0 +1,630 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This program generates Go code that applies rewrite rules to a Value.
+// The generated code implements a function of type func (v *Value) bool
+// which returns true iff if did something.
+// Ideas stolen from Swift: http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-2000-2.html
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "flag"
+ "fmt"
+ "go/format"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "regexp"
+ "sort"
+ "strings"
+)
+
+// rule syntax:
+// sexpr [&& extra conditions] -> [@block] sexpr
+//
+// sexpr are s-expressions (lisp-like parenthesized groupings)
+// sexpr ::= (opcode sexpr*)
+// | variable
+// | <type>
+// | [auxint]
+// | {aux}
+//
+// aux ::= variable | {code}
+// type ::= variable | {code}
+// variable ::= some token
+// opcode ::= one of the opcodes from ../op.go (without the Op prefix)
+
+// extra conditions is just a chunk of Go that evaluates to a boolean. It may use
+// variables declared in the matching sexpr. The variable "v" is predefined to be
+// the value matched by the entire rule.
+
+// If multiple rules match, the first one in file order is selected.
+
+var (
+ genLog = flag.Bool("log", false, "generate code that logs; for debugging only")
+)
+
+type Rule struct {
+ rule string
+ lineno int
+}
+
+func (r Rule) String() string {
+ return fmt.Sprintf("rule %q at line %d", r.rule, r.lineno)
+}
+
+// parse returns the matching part of the rule, additional conditions, and the result.
+func (r Rule) parse() (match, cond, result string) {
+ s := strings.Split(r.rule, "->")
+ if len(s) != 2 {
+ log.Fatalf("no arrow in %s", r)
+ }
+ match = strings.TrimSpace(s[0])
+ result = strings.TrimSpace(s[1])
+ cond = ""
+ if i := strings.Index(match, "&&"); i >= 0 {
+ cond = strings.TrimSpace(match[i+2:])
+ match = strings.TrimSpace(match[:i])
+ }
+ return match, cond, result
+}
+
+func genRules(arch arch) {
+ // Open input file.
+ text, err := os.Open(arch.name + ".rules")
+ if err != nil {
+ log.Fatalf("can't read rule file: %v", err)
+ }
+
+ // oprules contains a list of rules for each block and opcode
+ blockrules := map[string][]Rule{}
+ oprules := map[string][]Rule{}
+
+ // read rule file
+ scanner := bufio.NewScanner(text)
+ rule := ""
+ var lineno int
+ for scanner.Scan() {
+ lineno++
+ line := scanner.Text()
+ if i := strings.Index(line, "//"); i >= 0 {
+ // Remove comments. Note that this isn't string safe, so
+ // it will truncate lines with // inside strings. Oh well.
+ line = line[:i]
+ }
+ rule += " " + line
+ rule = strings.TrimSpace(rule)
+ if rule == "" {
+ continue
+ }
+ if !strings.Contains(rule, "->") {
+ continue
+ }
+ if strings.HasSuffix(rule, "->") {
+ continue
+ }
+ if unbalanced(rule) {
+ continue
+ }
+ op := strings.Split(rule, " ")[0][1:]
+ if op[len(op)-1] == ')' {
+ op = op[:len(op)-1] // rule has only opcode, e.g. (ConstNil) -> ...
+ }
+ if isBlock(op, arch) {
+ blockrules[op] = append(blockrules[op], Rule{rule: rule, lineno: lineno})
+ } else {
+ oprules[op] = append(oprules[op], Rule{rule: rule, lineno: lineno})
+ }
+ rule = ""
+ }
+ if err := scanner.Err(); err != nil {
+ log.Fatalf("scanner failed: %v\n", err)
+ }
+ if unbalanced(rule) {
+ log.Fatalf("unbalanced rule at line %d: %v\n", lineno, rule)
+ }
+
+ // Order all the ops.
+ var ops []string
+ for op := range oprules {
+ ops = append(ops, op)
+ }
+ sort.Strings(ops)
+
+ // Start output buffer, write header.
+ w := new(bytes.Buffer)
+ fmt.Fprintf(w, "// autogenerated from gen/%s.rules: do not edit!\n", arch.name)
+ fmt.Fprintln(w, "// generated with: cd gen; go run *.go")
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "package ssa")
+ if *genLog {
+ fmt.Fprintln(w, "import \"fmt\"")
+ }
+ fmt.Fprintln(w, "import \"math\"")
+ fmt.Fprintln(w, "var _ = math.MinInt8 // in case not otherwise used")
+
+ // Main rewrite routine is a switch on v.Op.
+ fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name)
+ fmt.Fprintf(w, "switch v.Op {\n")
+ for _, op := range ops {
+ fmt.Fprintf(w, "case %s:\n", opName(op, arch))
+ fmt.Fprintf(w, "return rewriteValue%s_%s(v, config)\n", arch.name, opName(op, arch))
+ }
+ fmt.Fprintf(w, "}\n")
+ fmt.Fprintf(w, "return false\n")
+ fmt.Fprintf(w, "}\n")
+
+ // Generate a routine per op. Note that we don't make one giant routine
+ // because it is too big for some compilers.
+ for _, op := range ops {
+ fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value, config *Config) bool {\n", arch.name, opName(op, arch))
+ fmt.Fprintln(w, "b := v.Block")
+ fmt.Fprintln(w, "_ = b")
+ for _, rule := range oprules[op] {
+ match, cond, result := rule.parse()
+ fmt.Fprintf(w, "// match: %s\n", match)
+ fmt.Fprintf(w, "// cond: %s\n", cond)
+ fmt.Fprintf(w, "// result: %s\n", result)
+
+ fmt.Fprintf(w, "for {\n")
+ genMatch(w, arch, match)
+
+ if cond != "" {
+ fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond)
+ }
+
+ genResult(w, arch, result)
+ if *genLog {
+ fmt.Fprintf(w, "fmt.Println(\"rewrite %s.rules:%d\")\n", arch.name, rule.lineno)
+ }
+ fmt.Fprintf(w, "return true\n")
+
+ fmt.Fprintf(w, "}\n")
+ }
+ fmt.Fprintf(w, "return false\n")
+ fmt.Fprintf(w, "}\n")
+ }
+
+ // Generate block rewrite function. There are only a few block types
+ // so we can make this one function with a switch.
+ fmt.Fprintf(w, "func rewriteBlock%s(b *Block) bool {\n", arch.name)
+ fmt.Fprintf(w, "switch b.Kind {\n")
+ ops = nil
+ for op := range blockrules {
+ ops = append(ops, op)
+ }
+ sort.Strings(ops)
+ for _, op := range ops {
+ fmt.Fprintf(w, "case %s:\n", blockName(op, arch))
+ for _, rule := range blockrules[op] {
+ match, cond, result := rule.parse()
+ fmt.Fprintf(w, "// match: %s\n", match)
+ fmt.Fprintf(w, "// cond: %s\n", cond)
+ fmt.Fprintf(w, "// result: %s\n", result)
+
+ fmt.Fprintf(w, "for {\n")
+
+ s := split(match[1 : len(match)-1]) // remove parens, then split
+
+ // check match of control value
+ if s[1] != "nil" {
+ fmt.Fprintf(w, "v := b.Control\n")
+ genMatch0(w, arch, s[1], "v", map[string]string{}, false)
+ }
+
+ // assign successor names
+ succs := s[2:]
+ for i, a := range succs {
+ if a != "_" {
+ fmt.Fprintf(w, "%s := b.Succs[%d]\n", a, i)
+ }
+ }
+
+ if cond != "" {
+ fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond)
+ }
+
+ // Rule matches. Generate result.
+ t := split(result[1 : len(result)-1]) // remove parens, then split
+ newsuccs := t[2:]
+
+ // Check if newsuccs is the same set as succs.
+ m := map[string]bool{}
+ for _, succ := range succs {
+ if m[succ] {
+ log.Fatalf("can't have a repeat successor name %s in %s", succ, rule)
+ }
+ m[succ] = true
+ }
+ for _, succ := range newsuccs {
+ if !m[succ] {
+ log.Fatalf("unknown successor %s in %s", succ, rule)
+ }
+ delete(m, succ)
+ }
+ if len(m) != 0 {
+ log.Fatalf("unmatched successors %v in %s", m, rule)
+ }
+
+ // Modify predecessor lists for no-longer-reachable blocks
+ for succ := range m {
+ fmt.Fprintf(w, "b.Func.removePredecessor(b, %s)\n", succ)
+ }
+
+ fmt.Fprintf(w, "b.Kind = %s\n", blockName(t[0], arch))
+ if t[1] == "nil" {
+ fmt.Fprintf(w, "b.Control = nil\n")
+ } else {
+ fmt.Fprintf(w, "b.Control = %s\n", genResult0(w, arch, t[1], new(int), false, false))
+ }
+ if len(newsuccs) < len(succs) {
+ fmt.Fprintf(w, "b.Succs = b.Succs[:%d]\n", len(newsuccs))
+ }
+ for i, a := range newsuccs {
+ fmt.Fprintf(w, "b.Succs[%d] = %s\n", i, a)
+ }
+ // Update branch prediction
+ switch {
+ case len(newsuccs) != 2:
+ fmt.Fprintln(w, "b.Likely = BranchUnknown")
+ case newsuccs[0] == succs[0] && newsuccs[1] == succs[1]:
+ // unchanged
+ case newsuccs[0] == succs[1] && newsuccs[1] == succs[0]:
+ // flipped
+ fmt.Fprintln(w, "b.Likely *= -1")
+ default:
+ // unknown
+ fmt.Fprintln(w, "b.Likely = BranchUnknown")
+ }
+
+ if *genLog {
+ fmt.Fprintf(w, "fmt.Println(\"rewrite %s.rules:%d\")\n", arch.name, rule.lineno)
+ }
+ fmt.Fprintf(w, "return true\n")
+
+ fmt.Fprintf(w, "}\n")
+ }
+ }
+ fmt.Fprintf(w, "}\n")
+ fmt.Fprintf(w, "return false\n")
+ fmt.Fprintf(w, "}\n")
+
+ // gofmt result
+ b := w.Bytes()
+ src, err := format.Source(b)
+ if err != nil {
+ fmt.Printf("%s\n", b)
+ panic(err)
+ }
+
+ // Write to file
+ err = ioutil.WriteFile("../rewrite"+arch.name+".go", src, 0666)
+ if err != nil {
+ log.Fatalf("can't write output: %v\n", err)
+ }
+}
+
+func genMatch(w io.Writer, arch arch, match string) {
+ genMatch0(w, arch, match, "v", map[string]string{}, true)
+}
+
+func genMatch0(w io.Writer, arch arch, match, v string, m map[string]string, top bool) {
+ if match[0] != '(' {
+ if _, ok := m[match]; ok {
+ // variable already has a definition. Check whether
+ // the old definition and the new definition match.
+ // For example, (add x x). Equality is just pointer equality
+ // on Values (so cse is important to do before lowering).
+ fmt.Fprintf(w, "if %s != %s {\nbreak\n}\n", v, match)
+ return
+ }
+ // remember that this variable references the given value
+ if match == "_" {
+ return
+ }
+ m[match] = v
+ fmt.Fprintf(w, "%s := %s\n", match, v)
+ return
+ }
+
+ // split body up into regions. Split by spaces/tabs, except those
+ // contained in () or {}.
+ s := split(match[1 : len(match)-1]) // remove parens, then split
+
+ // check op
+ if !top {
+ fmt.Fprintf(w, "if %s.Op != %s {\nbreak\n}\n", v, opName(s[0], arch))
+ }
+
+ // check type/aux/args
+ argnum := 0
+ for _, a := range s[1:] {
+ if a[0] == '<' {
+ // type restriction
+ t := a[1 : len(a)-1] // remove <>
+ if !isVariable(t) {
+ // code. We must match the results of this code.
+ fmt.Fprintf(w, "if %s.Type != %s {\nbreak\n}\n", v, t)
+ } else {
+ // variable
+ if u, ok := m[t]; ok {
+ // must match previous variable
+ fmt.Fprintf(w, "if %s.Type != %s {\nbreak\n}\n", v, u)
+ } else {
+ m[t] = v + ".Type"
+ fmt.Fprintf(w, "%s := %s.Type\n", t, v)
+ }
+ }
+ } else if a[0] == '[' {
+ // auxint restriction
+ x := a[1 : len(a)-1] // remove []
+ if !isVariable(x) {
+ // code
+ fmt.Fprintf(w, "if %s.AuxInt != %s {\nbreak\n}\n", v, x)
+ } else {
+ // variable
+ if y, ok := m[x]; ok {
+ fmt.Fprintf(w, "if %s.AuxInt != %s {\nbreak\n}\n", v, y)
+ } else {
+ m[x] = v + ".AuxInt"
+ fmt.Fprintf(w, "%s := %s.AuxInt\n", x, v)
+ }
+ }
+ } else if a[0] == '{' {
+ // auxint restriction
+ x := a[1 : len(a)-1] // remove {}
+ if !isVariable(x) {
+ // code
+ fmt.Fprintf(w, "if %s.Aux != %s {\nbreak\n}\n", v, x)
+ } else {
+ // variable
+ if y, ok := m[x]; ok {
+ fmt.Fprintf(w, "if %s.Aux != %s {\nbreak\n}\n", v, y)
+ } else {
+ m[x] = v + ".Aux"
+ fmt.Fprintf(w, "%s := %s.Aux\n", x, v)
+ }
+ }
+ } else {
+ // variable or sexpr
+ genMatch0(w, arch, a, fmt.Sprintf("%s.Args[%d]", v, argnum), m, false)
+ argnum++
+ }
+ }
+
+ variableLength := false
+ for _, op := range genericOps {
+ if op.name == s[0] && op.argLength == -1 {
+ variableLength = true
+ break
+ }
+ }
+ for _, op := range arch.ops {
+ if op.name == s[0] && op.argLength == -1 {
+ variableLength = true
+ break
+ }
+ }
+ if variableLength {
+ fmt.Fprintf(w, "if len(%s.Args) != %d {\nbreak\n}\n", v, argnum)
+ }
+}
+
+func genResult(w io.Writer, arch arch, result string) {
+ move := false
+ if result[0] == '@' {
+ // parse @block directive
+ s := strings.SplitN(result[1:], " ", 2)
+ fmt.Fprintf(w, "b = %s\n", s[0])
+ result = s[1]
+ move = true
+ }
+ genResult0(w, arch, result, new(int), true, move)
+}
+func genResult0(w io.Writer, arch arch, result string, alloc *int, top, move bool) string {
+ // TODO: when generating a constant result, use f.constVal to avoid
+ // introducing copies just to clean them up again.
+ if result[0] != '(' {
+ // variable
+ if top {
+ // It in not safe in general to move a variable between blocks
+ // (and particularly not a phi node).
+ // Introduce a copy.
+ fmt.Fprintf(w, "v.reset(OpCopy)\n")
+ fmt.Fprintf(w, "v.Type = %s.Type\n", result)
+ fmt.Fprintf(w, "v.AddArg(%s)\n", result)
+ }
+ return result
+ }
+
+ s := split(result[1 : len(result)-1]) // remove parens, then split
+
+ // Find the type of the variable.
+ var opType string
+ var typeOverride bool
+ for _, a := range s[1:] {
+ if a[0] == '<' {
+ // type restriction
+ opType = a[1 : len(a)-1] // remove <>
+ typeOverride = true
+ break
+ }
+ }
+ if opType == "" {
+ // find default type, if any
+ for _, op := range arch.ops {
+ if op.name == s[0] && op.typ != "" {
+ opType = typeName(op.typ)
+ break
+ }
+ }
+ }
+ if opType == "" {
+ for _, op := range genericOps {
+ if op.name == s[0] && op.typ != "" {
+ opType = typeName(op.typ)
+ break
+ }
+ }
+ }
+ var v string
+ if top && !move {
+ v = "v"
+ fmt.Fprintf(w, "v.reset(%s)\n", opName(s[0], arch))
+ if typeOverride {
+ fmt.Fprintf(w, "v.Type = %s\n", opType)
+ }
+ } else {
+ if opType == "" {
+ log.Fatalf("sub-expression %s (op=%s) must have a type", result, s[0])
+ }
+ v = fmt.Sprintf("v%d", *alloc)
+ *alloc++
+ fmt.Fprintf(w, "%s := b.NewValue0(v.Line, %s, %s)\n", v, opName(s[0], arch), opType)
+ if move {
+ // Rewrite original into a copy
+ fmt.Fprintf(w, "v.reset(OpCopy)\n")
+ fmt.Fprintf(w, "v.AddArg(%s)\n", v)
+ }
+ }
+ for _, a := range s[1:] {
+ if a[0] == '<' {
+ // type restriction, handled above
+ } else if a[0] == '[' {
+ // auxint restriction
+ x := a[1 : len(a)-1] // remove []
+ fmt.Fprintf(w, "%s.AuxInt = %s\n", v, x)
+ } else if a[0] == '{' {
+ // aux restriction
+ x := a[1 : len(a)-1] // remove {}
+ fmt.Fprintf(w, "%s.Aux = %s\n", v, x)
+ } else {
+ // regular argument (sexpr or variable)
+ x := genResult0(w, arch, a, alloc, false, move)
+ fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x)
+ }
+ }
+
+ return v
+}
+
+func split(s string) []string {
+ var r []string
+
+outer:
+ for s != "" {
+ d := 0 // depth of ({[<
+ var open, close byte // opening and closing markers ({[< or )}]>
+ nonsp := false // found a non-space char so far
+ for i := 0; i < len(s); i++ {
+ switch {
+ case d == 0 && s[i] == '(':
+ open, close = '(', ')'
+ d++
+ case d == 0 && s[i] == '<':
+ open, close = '<', '>'
+ d++
+ case d == 0 && s[i] == '[':
+ open, close = '[', ']'
+ d++
+ case d == 0 && s[i] == '{':
+ open, close = '{', '}'
+ d++
+ case d == 0 && (s[i] == ' ' || s[i] == '\t'):
+ if nonsp {
+ r = append(r, strings.TrimSpace(s[:i]))
+ s = s[i:]
+ continue outer
+ }
+ case d > 0 && s[i] == open:
+ d++
+ case d > 0 && s[i] == close:
+ d--
+ default:
+ nonsp = true
+ }
+ }
+ if d != 0 {
+ panic("imbalanced expression: " + s)
+ }
+ if nonsp {
+ r = append(r, strings.TrimSpace(s))
+ }
+ break
+ }
+ return r
+}
+
+// isBlock returns true if this op is a block opcode.
+func isBlock(name string, arch arch) bool {
+ for _, b := range genericBlocks {
+ if b.name == name {
+ return true
+ }
+ }
+ for _, b := range arch.blocks {
+ if b.name == name {
+ return true
+ }
+ }
+ return false
+}
+
+// opName converts from an op name specified in a rule file to an Op enum.
+// if the name matches a generic op, returns "Op" plus the specified name.
+// Otherwise, returns "Op" plus arch name plus op name.
+func opName(name string, arch arch) string {
+ for _, op := range genericOps {
+ if op.name == name {
+ return "Op" + name
+ }
+ }
+ return "Op" + arch.name + name
+}
+
+func blockName(name string, arch arch) string {
+ for _, b := range genericBlocks {
+ if b.name == name {
+ return "Block" + name
+ }
+ }
+ return "Block" + arch.name + name
+}
+
+// typeName returns the string to use to generate a type.
+func typeName(typ string) string {
+ switch typ {
+ case "Flags", "Mem", "Void", "Int128":
+ return "Type" + typ
+ default:
+ return "config.fe.Type" + typ + "()"
+ }
+}
+
+// unbalanced returns true if there aren't the same number of ( and ) in the string.
+func unbalanced(s string) bool {
+ var left, right int
+ for _, c := range s {
+ if c == '(' {
+ left++
+ }
+ if c == ')' {
+ right++
+ }
+ }
+ return left != right
+}
+
+// isVariable reports whether s is a single Go alphanumeric identifier.
+func isVariable(s string) bool {
+ b, err := regexp.MatchString("^[A-Za-z_][A-Za-z_0-9]*$", s)
+ if err != nil {
+ panic("bad variable regexp")
+ }
+ return b
+}
diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go
new file mode 100644
index 0000000..bb88a3e
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/html.go
@@ -0,0 +1,478 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "bytes"
+ "fmt"
+ "html"
+ "io"
+ "os"
+)
+
+type HTMLWriter struct {
+ Logger
+ *os.File
+}
+
+func NewHTMLWriter(path string, logger Logger, funcname string) *HTMLWriter {
+ out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+ if err != nil {
+ logger.Fatalf(0, "%v", err)
+ }
+ html := HTMLWriter{File: out, Logger: logger}
+ html.start(funcname)
+ return &html
+}
+
+func (w *HTMLWriter) start(name string) {
+ if w == nil {
+ return
+ }
+ w.WriteString("<html>")
+ w.WriteString(`<head>
+<style>
+
+#helplink {
+ margin-bottom: 15px;
+ display: block;
+ margin-top: -15px;
+}
+
+#help {
+ display: none;
+}
+
+.stats {
+ font-size: 60%;
+}
+
+table {
+ border: 1px solid black;
+ table-layout: fixed;
+ width: 300px;
+}
+
+th, td {
+ border: 1px solid black;
+ overflow: hidden;
+ width: 400px;
+ vertical-align: top;
+ padding: 5px;
+}
+
+li {
+ list-style-type: none;
+}
+
+li.ssa-long-value {
+ text-indent: -2em; /* indent wrapped lines */
+}
+
+li.ssa-value-list {
+ display: inline;
+}
+
+li.ssa-start-block {
+ padding: 0;
+ margin: 0;
+}
+
+li.ssa-end-block {
+ padding: 0;
+ margin: 0;
+}
+
+ul.ssa-print-func {
+ padding-left: 0;
+}
+
+dl.ssa-gen {
+ padding-left: 0;
+}
+
+dt.ssa-prog-src {
+ padding: 0;
+ margin: 0;
+ float: left;
+ width: 4em;
+}
+
+dd.ssa-prog {
+ padding: 0;
+ margin-right: 0;
+ margin-left: 4em;
+}
+
+.dead-value {
+ color: gray;
+}
+
+.dead-block {
+ opacity: 0.5;
+}
+
+.depcycle {
+ font-style: italic;
+}
+
+.highlight-yellow { background-color: yellow; }
+.highlight-aquamarine { background-color: aquamarine; }
+.highlight-coral { background-color: coral; }
+.highlight-lightpink { background-color: lightpink; }
+.highlight-lightsteelblue { background-color: lightsteelblue; }
+.highlight-palegreen { background-color: palegreen; }
+.highlight-powderblue { background-color: powderblue; }
+.highlight-lightgray { background-color: lightgray; }
+
+.outline-blue { outline: blue solid 2px; }
+.outline-red { outline: red solid 2px; }
+.outline-blueviolet { outline: blueviolet solid 2px; }
+.outline-darkolivegreen { outline: darkolivegreen solid 2px; }
+.outline-fuchsia { outline: fuchsia solid 2px; }
+.outline-sienna { outline: sienna solid 2px; }
+.outline-gold { outline: gold solid 2px; }
+
+</style>
+
+<script type="text/javascript">
+// ordered list of all available highlight colors
+var highlights = [
+ "highlight-yellow",
+ "highlight-aquamarine",
+ "highlight-coral",
+ "highlight-lightpink",
+ "highlight-lightsteelblue",
+ "highlight-palegreen",
+ "highlight-lightgray"
+];
+
+// state: which value is highlighted this color?
+var highlighted = {};
+for (var i = 0; i < highlights.length; i++) {
+ highlighted[highlights[i]] = "";
+}
+
+// ordered list of all available outline colors
+var outlines = [
+ "outline-blue",
+ "outline-red",
+ "outline-blueviolet",
+ "outline-darkolivegreen",
+ "outline-fuchsia",
+ "outline-sienna",
+ "outline-gold"
+];
+
+// state: which value is outlined this color?
+var outlined = {};
+for (var i = 0; i < outlines.length; i++) {
+ outlined[outlines[i]] = "";
+}
+
+window.onload = function() {
+ var ssaElemClicked = function(elem, event, selections, selected) {
+ event.stopPropagation()
+
+ // TODO: pushState with updated state and read it on page load,
+ // so that state can survive across reloads
+
+ // find all values with the same name
+ var c = elem.classList.item(0);
+ var x = document.getElementsByClassName(c);
+
+ // if selected, remove selections from all of them
+ // otherwise, attempt to add
+
+ var remove = "";
+ for (var i = 0; i < selections.length; i++) {
+ var color = selections[i];
+ if (selected[color] == c) {
+ remove = color;
+ break;
+ }
+ }
+
+ if (remove != "") {
+ for (var i = 0; i < x.length; i++) {
+ x[i].classList.remove(remove);
+ }
+ selected[remove] = "";
+ return;
+ }
+
+ // we're adding a selection
+ // find first available color
+ var avail = "";
+ for (var i = 0; i < selections.length; i++) {
+ var color = selections[i];
+ if (selected[color] == "") {
+ avail = color;
+ break;
+ }
+ }
+ if (avail == "") {
+ alert("out of selection colors; go add more");
+ return;
+ }
+
+ // set that as the selection
+ for (var i = 0; i < x.length; i++) {
+ x[i].classList.add(avail);
+ }
+ selected[avail] = c;
+ };
+
+ var ssaValueClicked = function(event) {
+ ssaElemClicked(this, event, highlights, highlighted);
+ }
+
+ var ssaBlockClicked = function(event) {
+ ssaElemClicked(this, event, outlines, outlined);
+ }
+
+ var ssavalues = document.getElementsByClassName("ssa-value");
+ for (var i = 0; i < ssavalues.length; i++) {
+ ssavalues[i].addEventListener('click', ssaValueClicked);
+ }
+
+ var ssalongvalues = document.getElementsByClassName("ssa-long-value");
+ for (var i = 0; i < ssalongvalues.length; i++) {
+ // don't attach listeners to li nodes, just the spans they contain
+ if (ssalongvalues[i].nodeName == "SPAN") {
+ ssalongvalues[i].addEventListener('click', ssaValueClicked);
+ }
+ }
+
+ var ssablocks = document.getElementsByClassName("ssa-block");
+ for (var i = 0; i < ssablocks.length; i++) {
+ ssablocks[i].addEventListener('click', ssaBlockClicked);
+ }
+};
+
+function toggle_visibility(id) {
+ var e = document.getElementById(id);
+ if(e.style.display == 'block')
+ e.style.display = 'none';
+ else
+ e.style.display = 'block';
+}
+</script>
+
+</head>`)
+ // TODO: Add javascript click handlers for blocks
+ // to outline that block across all phases
+ w.WriteString("<body>")
+ w.WriteString("<h1>")
+ w.WriteString(html.EscapeString(name))
+ w.WriteString("</h1>")
+ w.WriteString(`
+<a href="#" onclick="toggle_visibility('help');" id="helplink">help</a>
+<div id="help">
+
+<p>
+Click on a value or block to toggle highlighting of that value/block and its uses.
+Values and blocks are highlighted by ID, which may vary across passes.
+(TODO: Fix this.)
+</p>
+
+<p>
+Faded out values and blocks are dead code that has not been eliminated.
+</p>
+
+<p>
+Values printed in italics have a dependency cycle.
+</p>
+
+</div>
+`)
+ w.WriteString("<table>")
+ w.WriteString("<tr>")
+}
+
+func (w *HTMLWriter) Close() {
+ if w == nil {
+ return
+ }
+ w.WriteString("</tr>")
+ w.WriteString("</table>")
+ w.WriteString("</body>")
+ w.WriteString("</html>")
+ w.File.Close()
+}
+
+// WriteFunc writes f in a column headed by title.
+func (w *HTMLWriter) WriteFunc(title string, f *Func) {
+ if w == nil {
+ return // avoid generating HTML just to discard it
+ }
+ w.WriteColumn(title, f.HTML())
+ // TODO: Add visual representation of f's CFG.
+}
+
+// WriteColumn writes raw HTML in a column headed by title.
+// It is intended for pre- and post-compilation log output.
+func (w *HTMLWriter) WriteColumn(title string, html string) {
+ if w == nil {
+ return
+ }
+ w.WriteString("<td>")
+ w.WriteString("<h2>" + title + "</h2>")
+ w.WriteString(html)
+ w.WriteString("</td>")
+}
+
+func (w *HTMLWriter) Printf(msg string, v ...interface{}) {
+ if _, err := fmt.Fprintf(w.File, msg, v...); err != nil {
+ w.Fatalf(0, "%v", err)
+ }
+}
+
+func (w *HTMLWriter) WriteString(s string) {
+ if _, err := w.File.WriteString(s); err != nil {
+ w.Fatalf(0, "%v", err)
+ }
+}
+
+func (v *Value) HTML() string {
+ // TODO: Using the value ID as the class ignores the fact
+ // that value IDs get recycled and that some values
+ // are transmuted into other values.
+ return fmt.Sprintf("<span class=\"%[1]s ssa-value\">%[1]s</span>", v.String())
+}
+
+func (v *Value) LongHTML() string {
+ // TODO: Any intra-value formatting?
+ // I'm wary of adding too much visual noise,
+ // but a little bit might be valuable.
+ // We already have visual noise in the form of punctuation
+ // maybe we could replace some of that with formatting.
+ s := fmt.Sprintf("<span class=\"%s ssa-long-value\">", v.String())
+ s += fmt.Sprintf("%s = %s", v.HTML(), v.Op.String())
+ s += " <" + html.EscapeString(v.Type.String()) + ">"
+ if v.AuxInt != 0 {
+ s += fmt.Sprintf(" [%d]", v.AuxInt)
+ }
+ if v.Aux != nil {
+ if _, ok := v.Aux.(string); ok {
+ s += html.EscapeString(fmt.Sprintf(" {%q}", v.Aux))
+ } else {
+ s += html.EscapeString(fmt.Sprintf(" {%v}", v.Aux))
+ }
+ }
+ for _, a := range v.Args {
+ s += fmt.Sprintf(" %s", a.HTML())
+ }
+ r := v.Block.Func.RegAlloc
+ if int(v.ID) < len(r) && r[v.ID] != nil {
+ s += " : " + r[v.ID].Name()
+ }
+
+ s += "</span>"
+ return s
+}
+
+func (b *Block) HTML() string {
+ // TODO: Using the value ID as the class ignores the fact
+ // that value IDs get recycled and that some values
+ // are transmuted into other values.
+ return fmt.Sprintf("<span class=\"%[1]s ssa-block\">%[1]s</span>", html.EscapeString(b.String()))
+}
+
+func (b *Block) LongHTML() string {
+ // TODO: improve this for HTML?
+ s := fmt.Sprintf("<span class=\"%s ssa-block\">%s</span>", html.EscapeString(b.String()), html.EscapeString(b.Kind.String()))
+ if b.Aux != nil {
+ s += html.EscapeString(fmt.Sprintf(" {%v}", b.Aux))
+ }
+ if b.Control != nil {
+ s += fmt.Sprintf(" %s", b.Control.HTML())
+ }
+ if len(b.Succs) > 0 {
+ s += " →" // right arrow
+ for _, c := range b.Succs {
+ s += " " + c.HTML()
+ }
+ }
+ switch b.Likely {
+ case BranchUnlikely:
+ s += " (unlikely)"
+ case BranchLikely:
+ s += " (likely)"
+ }
+ return s
+}
+
+func (f *Func) HTML() string {
+ var buf bytes.Buffer
+ fmt.Fprint(&buf, "<code>")
+ p := htmlFuncPrinter{w: &buf}
+ fprintFunc(p, f)
+
+ // fprintFunc(&buf, f) // TODO: HTML, not text, <br /> for line breaks, etc.
+ fmt.Fprint(&buf, "</code>")
+ return buf.String()
+}
+
+type htmlFuncPrinter struct {
+ w io.Writer
+}
+
+func (p htmlFuncPrinter) header(f *Func) {}
+
+func (p htmlFuncPrinter) startBlock(b *Block, reachable bool) {
+ // TODO: Make blocks collapsable?
+ var dead string
+ if !reachable {
+ dead = "dead-block"
+ }
+ fmt.Fprintf(p.w, "<ul class=\"%s ssa-print-func %s\">", b, dead)
+ fmt.Fprintf(p.w, "<li class=\"ssa-start-block\">%s:", b.HTML())
+ if len(b.Preds) > 0 {
+ io.WriteString(p.w, " ←") // left arrow
+ for _, pred := range b.Preds {
+ fmt.Fprintf(p.w, " %s", pred.HTML())
+ }
+ }
+ io.WriteString(p.w, "</li>")
+ if len(b.Values) > 0 { // start list of values
+ io.WriteString(p.w, "<li class=\"ssa-value-list\">")
+ io.WriteString(p.w, "<ul>")
+ }
+}
+
+func (p htmlFuncPrinter) endBlock(b *Block) {
+ if len(b.Values) > 0 { // end list of values
+ io.WriteString(p.w, "</ul>")
+ io.WriteString(p.w, "</li>")
+ }
+ io.WriteString(p.w, "<li class=\"ssa-end-block\">")
+ fmt.Fprint(p.w, b.LongHTML())
+ io.WriteString(p.w, "</li>")
+ io.WriteString(p.w, "</ul>")
+ // io.WriteString(p.w, "</span>")
+}
+
+func (p htmlFuncPrinter) value(v *Value, live bool) {
+ var dead string
+ if !live {
+ dead = "dead-value"
+ }
+ fmt.Fprintf(p.w, "<li class=\"ssa-long-value %s\">", dead)
+ fmt.Fprint(p.w, v.LongHTML())
+ io.WriteString(p.w, "</li>")
+}
+
+func (p htmlFuncPrinter) startDepCycle() {
+ fmt.Fprintln(p.w, "<span class=\"depcycle\">")
+}
+
+func (p htmlFuncPrinter) endDepCycle() {
+ fmt.Fprintln(p.w, "</span>")
+}
+
+func (p htmlFuncPrinter) named(n LocalSlot, vals []*Value) {
+ // TODO
+}
diff --git a/src/cmd/compile/internal/ssa/id.go b/src/cmd/compile/internal/ssa/id.go
new file mode 100644
index 0000000..367e687
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/id.go
@@ -0,0 +1,28 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+type ID int32
+
+// idAlloc provides an allocator for unique integers.
+type idAlloc struct {
+ last ID
+}
+
+// get allocates an ID and returns it.
+func (a *idAlloc) get() ID {
+ x := a.last
+ x++
+ if x == 1<<31-1 {
+ panic("too many ids for this function")
+ }
+ a.last = x
+ return x
+}
+
+// num returns the maximum ID ever returned + 1.
+func (a *idAlloc) num() int {
+ return int(a.last + 1)
+}
diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go
new file mode 100644
index 0000000..8dd4b65
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/layout.go
@@ -0,0 +1,102 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// layout orders basic blocks in f with the goal of minimizing control flow instructions.
+// After this phase returns, the order of f.Blocks matters and is the order
+// in which those blocks will appear in the assembly output.
+func layout(f *Func) {
+ order := make([]*Block, 0, f.NumBlocks())
+ scheduled := make([]bool, f.NumBlocks())
+ idToBlock := make([]*Block, f.NumBlocks())
+ indegree := make([]int, f.NumBlocks())
+ posdegree := f.newSparseSet(f.NumBlocks()) // blocks with positive remaining degree
+ defer f.retSparseSet(posdegree)
+ zerodegree := f.newSparseSet(f.NumBlocks()) // blocks with zero remaining degree
+ defer f.retSparseSet(zerodegree)
+
+ // Initialize indegree of each block
+ for _, b := range f.Blocks {
+ idToBlock[b.ID] = b
+ indegree[b.ID] = len(b.Preds)
+ if len(b.Preds) == 0 {
+ zerodegree.add(b.ID)
+ } else {
+ posdegree.add(b.ID)
+ }
+ }
+
+ bid := f.Entry.ID
+blockloop:
+ for {
+ // add block to schedule
+ b := idToBlock[bid]
+ order = append(order, b)
+ scheduled[bid] = true
+ if len(order) == len(f.Blocks) {
+ break
+ }
+
+ for _, c := range b.Succs {
+ indegree[c.ID]--
+ if indegree[c.ID] == 0 {
+ posdegree.remove(c.ID)
+ zerodegree.add(c.ID)
+ }
+ }
+
+ // Pick the next block to schedule
+ // Pick among the successor blocks that have not been scheduled yet.
+
+ // Use likely direction if we have it.
+ var likely *Block
+ switch b.Likely {
+ case BranchLikely:
+ likely = b.Succs[0]
+ case BranchUnlikely:
+ likely = b.Succs[1]
+ }
+ if likely != nil && !scheduled[likely.ID] {
+ bid = likely.ID
+ continue
+ }
+
+ // Use degree for now.
+ bid = 0
+ mindegree := f.NumBlocks()
+ for _, c := range order[len(order)-1].Succs {
+ if scheduled[c.ID] {
+ continue
+ }
+ if indegree[c.ID] < mindegree {
+ mindegree = indegree[c.ID]
+ bid = c.ID
+ }
+ }
+ if bid != 0 {
+ continue
+ }
+ // TODO: improve this part
+ // No successor of the previously scheduled block works.
+ // Pick a zero-degree block if we can.
+ for zerodegree.size() > 0 {
+ cid := zerodegree.pop()
+ if !scheduled[cid] {
+ bid = cid
+ continue blockloop
+ }
+ }
+ // Still nothing, pick any block.
+ for {
+ cid := posdegree.pop()
+ if !scheduled[cid] {
+ bid = cid
+ continue blockloop
+ }
+ }
+ b.Fatalf("no block available for layout")
+ }
+ f.Blocks = order
+}
diff --git a/src/cmd/compile/internal/ssa/likelyadjust.go b/src/cmd/compile/internal/ssa/likelyadjust.go
new file mode 100755
index 0000000..6ce8705
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/likelyadjust.go
@@ -0,0 +1,300 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+)
+
+type loop struct {
+ header *Block // The header node of this (reducible) loop
+ outer *loop // loop containing this loop
+ // Next two fields not currently used, but cheap to maintain,
+ // and aid in computation of inner-ness and list of blocks.
+ nBlocks int32 // Number of blocks in this loop but not within inner loops
+ isInner bool // True if never discovered to contain a loop
+}
+
+// outerinner records that outer contains inner
+func (sdom sparseTree) outerinner(outer, inner *loop) {
+ oldouter := inner.outer
+ if oldouter == nil || sdom.isAncestorEq(oldouter.header, outer.header) {
+ inner.outer = outer
+ outer.isInner = false
+ }
+}
+
+type loopnest struct {
+ f *Func
+ b2l []*loop
+ po []*Block
+ sdom sparseTree
+ loops []*loop
+}
+
+func min8(a, b int8) int8 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func max8(a, b int8) int8 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+const (
+ blDEFAULT = 0
+ blMin = blDEFAULT
+ blCALL = 1
+ blRET = 2
+ blEXIT = 3
+)
+
+var bllikelies [4]string = [4]string{"default", "call", "ret", "exit"}
+
+func describePredictionAgrees(b *Block, prediction BranchPrediction) string {
+ s := ""
+ if prediction == b.Likely {
+ s = " (agrees with previous)"
+ } else if b.Likely != BranchUnknown {
+ s = " (disagrees with previous, ignored)"
+ }
+ return s
+}
+
+func describeBranchPrediction(f *Func, b *Block, likely, not int8, prediction BranchPrediction) {
+ f.Config.Warnl(int(b.Line), "Branch prediction rule %s < %s%s",
+ bllikelies[likely-blMin], bllikelies[not-blMin], describePredictionAgrees(b, prediction))
+}
+
+func likelyadjust(f *Func) {
+ // The values assigned to certain and local only matter
+ // in their rank order. 0 is default, more positive
+ // is less likely. It's possible to assign a negative
+ // unlikeliness (though not currently the case).
+ certain := make([]int8, f.NumBlocks()) // In the long run, all outcomes are at least this bad. Mainly for Exit
+ local := make([]int8, f.NumBlocks()) // for our immediate predecessors.
+
+ nest := loopnestfor(f)
+ po := nest.po
+ b2l := nest.b2l
+
+ for _, b := range po {
+ switch b.Kind {
+ case BlockExit:
+ // Very unlikely.
+ local[b.ID] = blEXIT
+ certain[b.ID] = blEXIT
+
+ // Ret, it depends.
+ case BlockRet, BlockRetJmp:
+ local[b.ID] = blRET
+ certain[b.ID] = blRET
+
+ // Calls. TODO not all calls are equal, names give useful clues.
+ // Any name-based heuristics are only relative to other calls,
+ // and less influential than inferences from loop structure.
+ case BlockCall:
+ local[b.ID] = blCALL
+ certain[b.ID] = max8(blCALL, certain[b.Succs[0].ID])
+
+ default:
+ if len(b.Succs) == 1 {
+ certain[b.ID] = certain[b.Succs[0].ID]
+ } else if len(b.Succs) == 2 {
+ // If successor is an unvisited backedge, it's in loop and we don't care.
+ // Its default unlikely is also zero which is consistent with favoring loop edges.
+ // Notice that this can act like a "reset" on unlikeliness at loops; the
+ // default "everything returns" unlikeliness is erased by min with the
+ // backedge likeliness; however a loop with calls on every path will be
+ // tagged with call cost. Net effect is that loop entry is favored.
+ b0 := b.Succs[0].ID
+ b1 := b.Succs[1].ID
+ certain[b.ID] = min8(certain[b0], certain[b1])
+
+ l := b2l[b.ID]
+ l0 := b2l[b0]
+ l1 := b2l[b1]
+
+ prediction := b.Likely
+ // Weak loop heuristic -- both source and at least one dest are in loops,
+ // and there is a difference in the destinations.
+ // TODO what is best arrangement for nested loops?
+ if l != nil && l0 != l1 {
+ noprediction := false
+ switch {
+ // prefer not to exit loops
+ case l1 == nil:
+ prediction = BranchLikely
+ case l0 == nil:
+ prediction = BranchUnlikely
+
+ // prefer to stay in loop, not exit to outer.
+ case l == l0:
+ prediction = BranchLikely
+ case l == l1:
+ prediction = BranchUnlikely
+ default:
+ noprediction = true
+ }
+ if f.pass.debug > 0 && !noprediction {
+ f.Config.Warnl(int(b.Line), "Branch prediction rule stay in loop%s",
+ describePredictionAgrees(b, prediction))
+ }
+
+ } else {
+ // Lacking loop structure, fall back on heuristics.
+ if certain[b1] > certain[b0] {
+ prediction = BranchLikely
+ if f.pass.debug > 0 {
+ describeBranchPrediction(f, b, certain[b0], certain[b1], prediction)
+ }
+ } else if certain[b0] > certain[b1] {
+ prediction = BranchUnlikely
+ if f.pass.debug > 0 {
+ describeBranchPrediction(f, b, certain[b1], certain[b0], prediction)
+ }
+ } else if local[b1] > local[b0] {
+ prediction = BranchLikely
+ if f.pass.debug > 0 {
+ describeBranchPrediction(f, b, local[b0], local[b1], prediction)
+ }
+ } else if local[b0] > local[b1] {
+ prediction = BranchUnlikely
+ if f.pass.debug > 0 {
+ describeBranchPrediction(f, b, local[b1], local[b0], prediction)
+ }
+ }
+ }
+ if b.Likely != prediction {
+ if b.Likely == BranchUnknown {
+ b.Likely = prediction
+ }
+ }
+ }
+ }
+ if f.pass.debug > 2 {
+ f.Config.Warnl(int(b.Line), "BP: Block %s, local=%s, certain=%s", b, bllikelies[local[b.ID]-blMin], bllikelies[certain[b.ID]-blMin])
+ }
+
+ }
+}
+
+func (l *loop) String() string {
+ return fmt.Sprintf("hdr:%s", l.header)
+}
+
+func (l *loop) LongString() string {
+ i := ""
+ o := ""
+ if l.isInner {
+ i = ", INNER"
+ }
+ if l.outer != nil {
+ o = ", o=" + l.outer.header.String()
+ }
+ return fmt.Sprintf("hdr:%s%s%s", l.header, i, o)
+}
+
+// nearestOuterLoop returns the outer loop of loop most nearly
+// containing block b; the header must dominate b. loop itself
+// is assumed to not be that loop. For acceptable performance,
+// we're relying on loop nests to not be terribly deep.
+func (l *loop) nearestOuterLoop(sdom sparseTree, b *Block) *loop {
+ var o *loop
+ for o = l.outer; o != nil && !sdom.isAncestorEq(o.header, b); o = o.outer {
+ }
+ return o
+}
+
+func loopnestfor(f *Func) *loopnest {
+ po := postorder(f)
+ dom := dominators(f)
+ sdom := newSparseTree(f, dom)
+ b2l := make([]*loop, f.NumBlocks())
+ loops := make([]*loop, 0)
+
+ // Reducible-loop-nest-finding.
+ for _, b := range po {
+ if f.pass.debug > 3 {
+ fmt.Printf("loop finding (0) at %s\n", b)
+ }
+
+ var innermost *loop // innermost header reachable from this block
+
+ // IF any successor s of b is in a loop headed by h
+ // AND h dominates b
+ // THEN b is in the loop headed by h.
+ //
+ // Choose the first/innermost such h.
+ //
+ // IF s itself dominates b, the s is a loop header;
+ // and there may be more than one such s.
+ // Since there's at most 2 successors, the inner/outer ordering
+ // between them can be established with simple comparisons.
+ for _, bb := range b.Succs {
+ l := b2l[bb.ID]
+
+ if sdom.isAncestorEq(bb, b) { // Found a loop header
+ if l == nil {
+ l = &loop{header: bb, isInner: true}
+ loops = append(loops, l)
+ b2l[bb.ID] = l
+ }
+ } else { // Perhaps a loop header is inherited.
+ // is there any loop containing our successor whose
+ // header dominates b?
+ if l != nil && !sdom.isAncestorEq(l.header, b) {
+ l = l.nearestOuterLoop(sdom, b)
+ }
+ }
+
+ if l == nil || innermost == l {
+ continue
+ }
+
+ if innermost == nil {
+ innermost = l
+ continue
+ }
+
+ if sdom.isAncestor(innermost.header, l.header) {
+ sdom.outerinner(innermost, l)
+ innermost = l
+ } else if sdom.isAncestor(l.header, innermost.header) {
+ sdom.outerinner(l, innermost)
+ }
+ }
+
+ if innermost != nil {
+ b2l[b.ID] = innermost
+ innermost.nBlocks++
+ }
+ }
+ if f.pass.debug > 1 && len(loops) > 0 {
+ fmt.Printf("Loops in %s:\n", f.Name)
+ for _, l := range loops {
+ fmt.Printf("%s, b=", l.LongString())
+ for _, b := range f.Blocks {
+ if b2l[b.ID] == l {
+ fmt.Printf(" %s", b)
+ }
+ }
+ fmt.Print("\n")
+ }
+ fmt.Printf("Nonloop blocks in %s:", f.Name)
+ for _, b := range f.Blocks {
+ if b2l[b.ID] == nil {
+ fmt.Printf(" %s", b)
+ }
+ }
+ fmt.Print("\n")
+ }
+ return &loopnest{f, b2l, po, sdom, loops}
+}
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
new file mode 100644
index 0000000..85f5255
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -0,0 +1,38 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "fmt"
+
+// A place that an ssa variable can reside.
+type Location interface {
+ Name() string // name to use in assembly templates: %rax, 16(%rsp), ...
+}
+
+// A Register is a machine register, like %rax.
+// They are numbered densely from 0 (for each architecture).
+type Register struct {
+ Num int32
+ name string
+}
+
+func (r *Register) Name() string {
+ return r.name
+}
+
+// A LocalSlot is a location in the stack frame.
+// It is (possibly a subpiece of) a PPARAM, PPARAMOUT, or PAUTO ONAME node.
+type LocalSlot struct {
+ N GCNode // an ONAME *gc.Node representing a variable on the stack
+ Type Type // type of slot
+ Off int64 // offset of slot in N
+}
+
+func (s LocalSlot) Name() string {
+ if s.Off == 0 {
+ return fmt.Sprintf("%s[%s]", s.N, s.Type)
+ }
+ return fmt.Sprintf("%s+%d[%s]", s.N, s.Off, s.Type)
+}
diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go
new file mode 100644
index 0000000..af0ee4c
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/lower.go
@@ -0,0 +1,34 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// convert to machine-dependent ops
+func lower(f *Func) {
+ // repeat rewrites until we find no more rewrites
+ applyRewrite(f, f.Config.lowerBlock, f.Config.lowerValue)
+}
+
+// checkLower checks for unlowered opcodes and fails if we find one.
+func checkLower(f *Func) {
+ // Needs to be a separate phase because it must run after both
+ // lowering and a subsequent dead code elimination (because lowering
+ // rules may leave dead generic ops behind).
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if !opcodeTable[v.Op].generic {
+ continue // lowered
+ }
+ switch v.Op {
+ case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill, OpVarLive:
+ continue // ok not to lower
+ }
+ s := "not lowered: " + v.Op.String() + " " + v.Type.SimpleString()
+ for _, a := range v.Args {
+ s += " " + a.Type.SimpleString()
+ }
+ f.Unimplementedf("%s", s)
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/magic.go b/src/cmd/compile/internal/ssa/magic.go
new file mode 100644
index 0000000..a8e84d5
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/magic.go
@@ -0,0 +1,260 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// A copy of the code in ../gc/subr.go.
+// We can't use it directly because it would generate
+// an import cycle. TODO: move to a common support package.
+
+// argument passing to/from
+// smagic and umagic
+type magic struct {
+ W int // input for both - width
+ S int // output for both - shift
+ Bad int // output for both - unexpected failure
+
+ // magic multiplier for signed literal divisors
+ Sd int64 // input - literal divisor
+ Sm int64 // output - multiplier
+
+ // magic multiplier for unsigned literal divisors
+ Ud uint64 // input - literal divisor
+ Um uint64 // output - multiplier
+ Ua int // output - adder
+}
+
+// magic number for signed division
+// see hacker's delight chapter 10
+func smagic(m *magic) {
+ var mask uint64
+
+ m.Bad = 0
+ switch m.W {
+ default:
+ m.Bad = 1
+ return
+
+ case 8:
+ mask = 0xff
+
+ case 16:
+ mask = 0xffff
+
+ case 32:
+ mask = 0xffffffff
+
+ case 64:
+ mask = 0xffffffffffffffff
+ }
+
+ two31 := mask ^ (mask >> 1)
+
+ p := m.W - 1
+ ad := uint64(m.Sd)
+ if m.Sd < 0 {
+ ad = -uint64(m.Sd)
+ }
+
+ // bad denominators
+ if ad == 0 || ad == 1 || ad == two31 {
+ m.Bad = 1
+ return
+ }
+
+ t := two31
+ ad &= mask
+
+ anc := t - 1 - t%ad
+ anc &= mask
+
+ q1 := two31 / anc
+ r1 := two31 - q1*anc
+ q1 &= mask
+ r1 &= mask
+
+ q2 := two31 / ad
+ r2 := two31 - q2*ad
+ q2 &= mask
+ r2 &= mask
+
+ var delta uint64
+ for {
+ p++
+ q1 <<= 1
+ r1 <<= 1
+ q1 &= mask
+ r1 &= mask
+ if r1 >= anc {
+ q1++
+ r1 -= anc
+ q1 &= mask
+ r1 &= mask
+ }
+
+ q2 <<= 1
+ r2 <<= 1
+ q2 &= mask
+ r2 &= mask
+ if r2 >= ad {
+ q2++
+ r2 -= ad
+ q2 &= mask
+ r2 &= mask
+ }
+
+ delta = ad - r2
+ delta &= mask
+ if q1 < delta || (q1 == delta && r1 == 0) {
+ continue
+ }
+
+ break
+ }
+
+ m.Sm = int64(q2 + 1)
+ if uint64(m.Sm)&two31 != 0 {
+ m.Sm |= ^int64(mask)
+ }
+ m.S = p - m.W
+}
+
+// magic number for unsigned division
+// see hacker's delight chapter 10
+func umagic(m *magic) {
+ var mask uint64
+
+ m.Bad = 0
+ m.Ua = 0
+
+ switch m.W {
+ default:
+ m.Bad = 1
+ return
+
+ case 8:
+ mask = 0xff
+
+ case 16:
+ mask = 0xffff
+
+ case 32:
+ mask = 0xffffffff
+
+ case 64:
+ mask = 0xffffffffffffffff
+ }
+
+ two31 := mask ^ (mask >> 1)
+
+ m.Ud &= mask
+ if m.Ud == 0 || m.Ud == two31 {
+ m.Bad = 1
+ return
+ }
+
+ nc := mask - (-m.Ud&mask)%m.Ud
+ p := m.W - 1
+
+ q1 := two31 / nc
+ r1 := two31 - q1*nc
+ q1 &= mask
+ r1 &= mask
+
+ q2 := (two31 - 1) / m.Ud
+ r2 := (two31 - 1) - q2*m.Ud
+ q2 &= mask
+ r2 &= mask
+
+ var delta uint64
+ for {
+ p++
+ if r1 >= nc-r1 {
+ q1 <<= 1
+ q1++
+ r1 <<= 1
+ r1 -= nc
+ } else {
+ q1 <<= 1
+ r1 <<= 1
+ }
+
+ q1 &= mask
+ r1 &= mask
+ if r2+1 >= m.Ud-r2 {
+ if q2 >= two31-1 {
+ m.Ua = 1
+ }
+
+ q2 <<= 1
+ q2++
+ r2 <<= 1
+ r2++
+ r2 -= m.Ud
+ } else {
+ if q2 >= two31 {
+ m.Ua = 1
+ }
+
+ q2 <<= 1
+ r2 <<= 1
+ r2++
+ }
+
+ q2 &= mask
+ r2 &= mask
+
+ delta = m.Ud - 1 - r2
+ delta &= mask
+
+ if p < m.W+m.W {
+ if q1 < delta || (q1 == delta && r1 == 0) {
+ continue
+ }
+ }
+
+ break
+ }
+
+ m.Um = q2 + 1
+ m.S = p - m.W
+}
+
+// adaptors for use by rewrite rules
+func smagic64ok(d int64) bool {
+ m := magic{W: 64, Sd: d}
+ smagic(&m)
+ return m.Bad == 0
+}
+func smagic64m(d int64) int64 {
+ m := magic{W: 64, Sd: d}
+ smagic(&m)
+ return m.Sm
+}
+func smagic64s(d int64) int64 {
+ m := magic{W: 64, Sd: d}
+ smagic(&m)
+ return int64(m.S)
+}
+
+func umagic64ok(d int64) bool {
+ m := magic{W: 64, Ud: uint64(d)}
+ umagic(&m)
+ return m.Bad == 0
+}
+func umagic64m(d int64) int64 {
+ m := magic{W: 64, Ud: uint64(d)}
+ umagic(&m)
+ return int64(m.Um)
+}
+func umagic64s(d int64) int64 {
+ m := magic{W: 64, Ud: uint64(d)}
+ umagic(&m)
+ return int64(m.S)
+}
+func umagic64a(d int64) bool {
+ m := magic{W: 64, Ud: uint64(d)}
+ umagic(&m)
+ return m.Ua != 0
+}
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
new file mode 100644
index 0000000..f8caa7b
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -0,0 +1,163 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// TODO: return value from newobject/newarray is non-nil.
+
+// nilcheckelim eliminates unnecessary nil checks.
+func nilcheckelim(f *Func) {
+ // A nil check is redundant if the same nil check was successful in a
+ // dominating block. The efficacy of this pass depends heavily on the
+ // efficacy of the cse pass.
+ idom := dominators(f)
+ domTree := make([][]*Block, f.NumBlocks())
+
+ // Create a block ID -> [dominees] mapping
+ for _, b := range f.Blocks {
+ if dom := idom[b.ID]; dom != nil {
+ domTree[dom.ID] = append(domTree[dom.ID], b)
+ }
+ }
+
+ // TODO: Eliminate more nil checks.
+ // We can recursively remove any chain of fixed offset calculations,
+ // i.e. struct fields and array elements, even with non-constant
+ // indices: x is non-nil iff x.a.b[i].c is.
+
+ type walkState int
+ const (
+ Work walkState = iota // clear nil check if we should and traverse to dominees regardless
+ RecPtr // record the pointer as being nil checked
+ ClearPtr
+ )
+
+ type bp struct {
+ block *Block // block, or nil in RecPtr/ClearPtr state
+ ptr *Value // if non-nil, ptr that is to be set/cleared in RecPtr/ClearPtr state
+ op walkState
+ }
+
+ work := make([]bp, 0, 256)
+ work = append(work, bp{block: f.Entry})
+
+ // map from value ID to bool indicating if value is known to be non-nil
+ // in the current dominator path being walked. This slice is updated by
+ // walkStates to maintain the known non-nil values.
+ nonNilValues := make([]bool, f.NumValues())
+
+ // make an initial pass identifying any non-nil values
+ for _, b := range f.Blocks {
+ // a value resulting from taking the address of a
+ // value, or a value constructed from an offset of a
+ // non-nil ptr (OpAddPtr) implies it is non-nil
+ for _, v := range b.Values {
+ if v.Op == OpAddr || v.Op == OpAddPtr {
+ nonNilValues[v.ID] = true
+ } else if v.Op == OpPhi {
+ // phis whose arguments are all non-nil
+ // are non-nil
+ argsNonNil := true
+ for _, a := range v.Args {
+ if !nonNilValues[a.ID] {
+ argsNonNil = false
+ }
+ }
+ if argsNonNil {
+ nonNilValues[v.ID] = true
+ }
+ }
+ }
+ }
+
+ // perform a depth first walk of the dominee tree
+ for len(work) > 0 {
+ node := work[len(work)-1]
+ work = work[:len(work)-1]
+
+ switch node.op {
+ case Work:
+ checked := checkedptr(node.block) // ptr being checked for nil/non-nil
+ nonnil := nonnilptr(node.block) // ptr that is non-nil due to this blocks pred
+
+ if checked != nil {
+ // already have a nilcheck in the dominator path, or this block is a success
+ // block for the same value it is checking
+ if nonNilValues[checked.ID] || checked == nonnil {
+ // Eliminate the nil check.
+ // The deadcode pass will remove vestigial values,
+ // and the fuse pass will join this block with its successor.
+
+ // Logging in the style of the former compiler -- and omit line 1,
+ // which is usually in generated code.
+ if f.Config.Debug_checknil() && int(node.block.Control.Line) > 1 {
+ f.Config.Warnl(int(node.block.Control.Line), "removed nil check")
+ }
+
+ switch node.block.Kind {
+ case BlockIf:
+ node.block.Kind = BlockFirst
+ node.block.Control = nil
+ case BlockCheck:
+ node.block.Kind = BlockPlain
+ node.block.Control = nil
+ default:
+ f.Fatalf("bad block kind in nilcheck %s", node.block.Kind)
+ }
+ }
+ }
+
+ if nonnil != nil && !nonNilValues[nonnil.ID] {
+ // this is a new nilcheck so add a ClearPtr node to clear the
+ // ptr from the map of nil checks once we traverse
+ // back up the tree
+ work = append(work, bp{op: ClearPtr, ptr: nonnil})
+ }
+
+ // add all dominated blocks to the work list
+ for _, w := range domTree[node.block.ID] {
+ work = append(work, bp{block: w})
+ }
+
+ if nonnil != nil && !nonNilValues[nonnil.ID] {
+ work = append(work, bp{op: RecPtr, ptr: nonnil})
+ }
+ case RecPtr:
+ nonNilValues[node.ptr.ID] = true
+ continue
+ case ClearPtr:
+ nonNilValues[node.ptr.ID] = false
+ continue
+ }
+ }
+}
+
+// checkedptr returns the Value, if any,
+// that is used in a nil check in b's Control op.
+func checkedptr(b *Block) *Value {
+ if b.Kind == BlockCheck {
+ return b.Control.Args[0]
+ }
+ if b.Kind == BlockIf && b.Control.Op == OpIsNonNil {
+ return b.Control.Args[0]
+ }
+ return nil
+}
+
+// nonnilptr returns the Value, if any,
+// that is non-nil due to b being the successor block
+// of an OpIsNonNil or OpNilCheck block for the value and having a single
+// predecessor.
+func nonnilptr(b *Block) *Value {
+ if len(b.Preds) == 1 {
+ bp := b.Preds[0]
+ if bp.Kind == BlockCheck {
+ return bp.Control.Args[0]
+ }
+ if bp.Kind == BlockIf && bp.Control.Op == OpIsNonNil && bp.Succs[0] == b {
+ return bp.Control.Args[0]
+ }
+ }
+ return nil
+}
diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go
new file mode 100644
index 0000000..2d1dbc6
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/nilcheck_test.go
@@ -0,0 +1,433 @@
+package ssa
+
+import (
+ "strconv"
+ "testing"
+)
+
+func BenchmarkNilCheckDeep1(b *testing.B) { benchmarkNilCheckDeep(b, 1) }
+func BenchmarkNilCheckDeep10(b *testing.B) { benchmarkNilCheckDeep(b, 10) }
+func BenchmarkNilCheckDeep100(b *testing.B) { benchmarkNilCheckDeep(b, 100) }
+func BenchmarkNilCheckDeep1000(b *testing.B) { benchmarkNilCheckDeep(b, 1000) }
+func BenchmarkNilCheckDeep10000(b *testing.B) { benchmarkNilCheckDeep(b, 10000) }
+
+// benchmarkNilCheckDeep is a stress test of nilcheckelim.
+// It uses the worst possible input: A linear string of
+// nil checks, none of which can be eliminated.
+// Run with multiple depths to observe big-O behavior.
+func benchmarkNilCheckDeep(b *testing.B, depth int) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+
+ var blocs []bloc
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto(blockn(0)),
+ ),
+ )
+ for i := 0; i < depth; i++ {
+ blocs = append(blocs,
+ Bloc(blockn(i),
+ Valu(ptrn(i), OpAddr, ptrType, 0, nil, "sb"),
+ Valu(booln(i), OpIsNonNil, TypeBool, 0, nil, ptrn(i)),
+ If(booln(i), blockn(i+1), "exit"),
+ ),
+ )
+ }
+ blocs = append(blocs,
+ Bloc(blockn(depth), Goto("exit")),
+ Bloc("exit", Exit("mem")),
+ )
+
+ c := NewConfig("amd64", DummyFrontend{b}, nil, true)
+ fun := Fun(c, "entry", blocs...)
+
+ CheckFunc(fun.f)
+ b.SetBytes(int64(depth)) // helps for eyeballing linearity
+ b.ResetTimer()
+ b.ReportAllocs()
+
+ for i := 0; i < b.N; i++ {
+ nilcheckelim(fun.f)
+ }
+}
+
+func blockn(n int) string { return "b" + strconv.Itoa(n) }
+func ptrn(n int) string { return "p" + strconv.Itoa(n) }
+func booln(n int) string { return "c" + strconv.Itoa(n) }
+
+func isNilCheck(b *Block) bool {
+ return b.Kind == BlockIf && b.Control.Op == OpIsNonNil
+}
+
+// TestNilcheckSimple verifies that a second repeated nilcheck is removed.
+func TestNilcheckSimple(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "secondCheck", "exit")),
+ Bloc("secondCheck",
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool2", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ t.Errorf("secondCheck was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckDomOrder ensures that the nil check elimination isn't dependant
+// on the order of the dominees.
+func TestNilcheckDomOrder(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "secondCheck", "exit")),
+ Bloc("exit",
+ Exit("mem")),
+ Bloc("secondCheck",
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool2", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ t.Errorf("secondCheck was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckAddr verifies that nilchecks of OpAddr constructed values are removed.
+func TestNilcheckAddr(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpAddr, ptrType, 0, nil, "sb"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["checkPtr"] && isNilCheck(b) {
+ t.Errorf("checkPtr was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckAddPtr verifies that nilchecks of OpAddPtr constructed values are removed.
+func TestNilcheckAddPtr(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("off", OpConst64, TypeInt64, 20, nil),
+ Valu("ptr1", OpAddPtr, ptrType, 0, nil, "sb", "off"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["checkPtr"] && isNilCheck(b) {
+ t.Errorf("checkPtr was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckPhi tests that nil checks of phis, for which all values are known to be
+// non-nil are removed.
+func TestNilcheckPhi(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Valu("sp", OpSP, TypeInvalid, 0, nil),
+ Valu("baddr", OpAddr, TypeBool, 0, "b", "sp"),
+ Valu("bool1", OpLoad, TypeBool, 0, nil, "baddr", "mem"),
+ If("bool1", "b1", "b2")),
+ Bloc("b1",
+ Valu("ptr1", OpAddr, ptrType, 0, nil, "sb"),
+ Goto("checkPtr")),
+ Bloc("b2",
+ Valu("ptr2", OpAddr, ptrType, 0, nil, "sb"),
+ Goto("checkPtr")),
+ // both ptr1 and ptr2 are guaranteed non-nil here
+ Bloc("checkPtr",
+ Valu("phi", OpPhi, ptrType, 0, nil, "ptr1", "ptr2"),
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "phi"),
+ If("bool2", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["checkPtr"] && isNilCheck(b) {
+ t.Errorf("checkPtr was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckKeepRemove verifies that duplicate checks of the same pointer
+// are removed, but checks of different pointers are not.
+func TestNilcheckKeepRemove(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "differentCheck", "exit")),
+ Bloc("differentCheck",
+ Valu("ptr2", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr2"),
+ If("bool2", "secondCheck", "exit")),
+ Bloc("secondCheck",
+ Valu("bool3", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool3", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ foundDifferentCheck := false
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ t.Errorf("secondCheck was not eliminated")
+ }
+ if b == fun.blocks["differentCheck"] && isNilCheck(b) {
+ foundDifferentCheck = true
+ }
+ }
+ if !foundDifferentCheck {
+ t.Errorf("removed differentCheck, but shouldn't have")
+ }
+}
+
+// TestNilcheckInFalseBranch tests that nil checks in the false branch of an nilcheck
+// block are *not* removed.
+func TestNilcheckInFalseBranch(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool1", "extra", "secondCheck")),
+ Bloc("secondCheck",
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool2", "extra", "thirdCheck")),
+ Bloc("thirdCheck",
+ Valu("bool3", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool3", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ foundSecondCheck := false
+ foundThirdCheck := false
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ foundSecondCheck = true
+ }
+ if b == fun.blocks["thirdCheck"] && isNilCheck(b) {
+ foundThirdCheck = true
+ }
+ }
+ if !foundSecondCheck {
+ t.Errorf("removed secondCheck, but shouldn't have [false branch]")
+ }
+ if !foundThirdCheck {
+ t.Errorf("removed thirdCheck, but shouldn't have [false branch]")
+ }
+}
+
+// TestNilcheckUser verifies that a user nil check that dominates a generated nil check
+// wil remove the generated nil check.
+func TestNilcheckUser(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("nilptr", OpConstNil, ptrType, 0, nil),
+ Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"),
+ If("bool1", "secondCheck", "exit")),
+ Bloc("secondCheck",
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool2", "extra", "exit")),
+ Bloc("extra",
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ // we need the opt here to rewrite the user nilcheck
+ opt(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ t.Errorf("secondCheck was not eliminated")
+ }
+ }
+}
+
+// TestNilcheckBug reproduces a bug in nilcheckelim found by compiling math/big
+func TestNilcheckBug(t *testing.T) {
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
+ c := NewConfig("amd64", DummyFrontend{t}, nil, true)
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto("checkPtr")),
+ Bloc("checkPtr",
+ Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
+ Valu("nilptr", OpConstNil, ptrType, 0, nil),
+ Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"),
+ If("bool1", "secondCheck", "couldBeNil")),
+ Bloc("couldBeNil",
+ Goto("secondCheck")),
+ Bloc("secondCheck",
+ Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr1"),
+ If("bool2", "extra", "exit")),
+ Bloc("extra",
+ // prevent fuse from eliminating this block
+ Valu("store", OpStore, TypeMem, 8, nil, "ptr1", "nilptr", "mem"),
+ Goto("exit")),
+ Bloc("exit",
+ Valu("phi", OpPhi, TypeMem, 0, nil, "mem", "store"),
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ // we need the opt here to rewrite the user nilcheck
+ opt(fun.f)
+ nilcheckelim(fun.f)
+
+ // clean up the removed nil check
+ fuse(fun.f)
+ deadcode(fun.f)
+
+ CheckFunc(fun.f)
+ foundSecondCheck := false
+ for _, b := range fun.f.Blocks {
+ if b == fun.blocks["secondCheck"] && isNilCheck(b) {
+ foundSecondCheck = true
+ }
+ }
+ if !foundSecondCheck {
+ t.Errorf("secondCheck was eliminated, but shouldn't have")
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
new file mode 100644
index 0000000..7b2a8f8
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -0,0 +1,118 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "fmt"
+
+// An Op encodes the specific operation that a Value performs.
+// Opcodes' semantics can be modified by the type and aux fields of the Value.
+// For instance, OpAdd can be 32 or 64 bit, signed or unsigned, float or complex, depending on Value.Type.
+// Semantics of each op are described in the opcode files in gen/*Ops.go.
+// There is one file for generic (architecture-independent) ops and one file
+// for each architecture.
+type Op int32
+
+type opInfo struct {
+ name string
+ asm int
+ reg regInfo
+ auxType auxType
+ argLen int32 // the number of arugments, -1 if variable length
+ generic bool // this is a generic (arch-independent) opcode
+ rematerializeable bool // this op is rematerializeable
+ commutative bool // this operation is commutative (e.g. addition)
+}
+
+type inputInfo struct {
+ idx int // index in Args array
+ regs regMask // allowed input registers
+}
+
+type regInfo struct {
+ inputs []inputInfo // ordered in register allocation order
+ clobbers regMask
+ outputs []regMask // NOTE: values can only have 1 output for now.
+}
+
+type auxType int8
+
+const (
+ auxNone auxType = iota
+ auxBool // auxInt is 0/1 for false/true
+ auxInt8 // auxInt is an 8-bit integer
+ auxInt16 // auxInt is a 16-bit integer
+ auxInt32 // auxInt is a 32-bit integer
+ auxInt64 // auxInt is a 64-bit integer
+ auxFloat // auxInt is a float64 (encoded with math.Float64bits)
+ auxString // auxInt is a string
+ auxSym // aux is a symbol
+ auxSymOff // aux is a symbol, auxInt is an offset
+ auxSymValAndOff // aux is a symbol, auxInt is a ValAndOff
+)
+
+// A ValAndOff is used by the several opcodes. It holds
+// both a value and a pointer offset.
+// A ValAndOff is intended to be encoded into an AuxInt field.
+// The zero ValAndOff encodes a value of 0 and an offset of 0.
+// The high 32 bits hold a value.
+// The low 32 bits hold a pointer offset.
+type ValAndOff int64
+
+func (x ValAndOff) Val() int64 {
+ return int64(x) >> 32
+}
+func (x ValAndOff) Off() int64 {
+ return int64(int32(x))
+}
+func (x ValAndOff) Int64() int64 {
+ return int64(x)
+}
+func (x ValAndOff) String() string {
+ return fmt.Sprintf("val=%d,off=%d", x.Val(), x.Off())
+}
+
+// validVal reports whether the value can be used
+// as an argument to makeValAndOff.
+func validVal(val int64) bool {
+ return val == int64(int32(val))
+}
+
+// validOff reports whether the offset can be used
+// as an argument to makeValAndOff.
+func validOff(off int64) bool {
+ return off == int64(int32(off))
+}
+
+// validValAndOff reports whether we can fit the value and offset into
+// a ValAndOff value.
+func validValAndOff(val, off int64) bool {
+ if !validVal(val) {
+ return false
+ }
+ if !validOff(off) {
+ return false
+ }
+ return true
+}
+
+// makeValAndOff encodes a ValAndOff into an int64 suitable for storing in an AuxInt field.
+func makeValAndOff(val, off int64) int64 {
+ if !validValAndOff(val, off) {
+ panic("invalid makeValAndOff")
+ }
+ return ValAndOff(val<<32 + int64(uint32(off))).Int64()
+}
+
+func (x ValAndOff) canAdd(off int64) bool {
+ newoff := x.Off() + off
+ return newoff == int64(int32(newoff))
+}
+
+func (x ValAndOff) add(off int64) int64 {
+ if !x.canAdd(off) {
+ panic("invalid ValAndOff.add")
+ }
+ return makeValAndOff(x.Val(), x.Off()+off)
+}
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
new file mode 100644
index 0000000..a48766ff
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -0,0 +1,5264 @@
+// autogenerated: do not edit!
+// generated from gen/*Ops.go
+
+package ssa
+
+import "cmd/internal/obj/x86"
+
+const (
+ BlockInvalid BlockKind = iota
+
+ BlockAMD64EQ
+ BlockAMD64NE
+ BlockAMD64LT
+ BlockAMD64LE
+ BlockAMD64GT
+ BlockAMD64GE
+ BlockAMD64ULT
+ BlockAMD64ULE
+ BlockAMD64UGT
+ BlockAMD64UGE
+ BlockAMD64EQF
+ BlockAMD64NEF
+ BlockAMD64ORD
+ BlockAMD64NAN
+
+ BlockPlain
+ BlockIf
+ BlockCall
+ BlockCheck
+ BlockRet
+ BlockRetJmp
+ BlockExit
+ BlockFirst
+ BlockDead
+)
+
+var blockString = [...]string{
+ BlockInvalid: "BlockInvalid",
+
+ BlockAMD64EQ: "EQ",
+ BlockAMD64NE: "NE",
+ BlockAMD64LT: "LT",
+ BlockAMD64LE: "LE",
+ BlockAMD64GT: "GT",
+ BlockAMD64GE: "GE",
+ BlockAMD64ULT: "ULT",
+ BlockAMD64ULE: "ULE",
+ BlockAMD64UGT: "UGT",
+ BlockAMD64UGE: "UGE",
+ BlockAMD64EQF: "EQF",
+ BlockAMD64NEF: "NEF",
+ BlockAMD64ORD: "ORD",
+ BlockAMD64NAN: "NAN",
+
+ BlockPlain: "Plain",
+ BlockIf: "If",
+ BlockCall: "Call",
+ BlockCheck: "Check",
+ BlockRet: "Ret",
+ BlockRetJmp: "RetJmp",
+ BlockExit: "Exit",
+ BlockFirst: "First",
+ BlockDead: "Dead",
+}
+
+func (k BlockKind) String() string { return blockString[k] }
+
+const (
+ OpInvalid Op = iota
+
+ OpAMD64ADDSS
+ OpAMD64ADDSD
+ OpAMD64SUBSS
+ OpAMD64SUBSD
+ OpAMD64MULSS
+ OpAMD64MULSD
+ OpAMD64DIVSS
+ OpAMD64DIVSD
+ OpAMD64MOVSSload
+ OpAMD64MOVSDload
+ OpAMD64MOVSSconst
+ OpAMD64MOVSDconst
+ OpAMD64MOVSSloadidx4
+ OpAMD64MOVSDloadidx8
+ OpAMD64MOVSSstore
+ OpAMD64MOVSDstore
+ OpAMD64MOVSSstoreidx4
+ OpAMD64MOVSDstoreidx8
+ OpAMD64ADDQ
+ OpAMD64ADDL
+ OpAMD64ADDW
+ OpAMD64ADDB
+ OpAMD64ADDQconst
+ OpAMD64ADDLconst
+ OpAMD64ADDWconst
+ OpAMD64ADDBconst
+ OpAMD64SUBQ
+ OpAMD64SUBL
+ OpAMD64SUBW
+ OpAMD64SUBB
+ OpAMD64SUBQconst
+ OpAMD64SUBLconst
+ OpAMD64SUBWconst
+ OpAMD64SUBBconst
+ OpAMD64MULQ
+ OpAMD64MULL
+ OpAMD64MULW
+ OpAMD64MULB
+ OpAMD64MULQconst
+ OpAMD64MULLconst
+ OpAMD64MULWconst
+ OpAMD64MULBconst
+ OpAMD64HMULQ
+ OpAMD64HMULL
+ OpAMD64HMULW
+ OpAMD64HMULB
+ OpAMD64HMULQU
+ OpAMD64HMULLU
+ OpAMD64HMULWU
+ OpAMD64HMULBU
+ OpAMD64AVGQU
+ OpAMD64DIVQ
+ OpAMD64DIVL
+ OpAMD64DIVW
+ OpAMD64DIVQU
+ OpAMD64DIVLU
+ OpAMD64DIVWU
+ OpAMD64MODQ
+ OpAMD64MODL
+ OpAMD64MODW
+ OpAMD64MODQU
+ OpAMD64MODLU
+ OpAMD64MODWU
+ OpAMD64ANDQ
+ OpAMD64ANDL
+ OpAMD64ANDW
+ OpAMD64ANDB
+ OpAMD64ANDQconst
+ OpAMD64ANDLconst
+ OpAMD64ANDWconst
+ OpAMD64ANDBconst
+ OpAMD64ORQ
+ OpAMD64ORL
+ OpAMD64ORW
+ OpAMD64ORB
+ OpAMD64ORQconst
+ OpAMD64ORLconst
+ OpAMD64ORWconst
+ OpAMD64ORBconst
+ OpAMD64XORQ
+ OpAMD64XORL
+ OpAMD64XORW
+ OpAMD64XORB
+ OpAMD64XORQconst
+ OpAMD64XORLconst
+ OpAMD64XORWconst
+ OpAMD64XORBconst
+ OpAMD64CMPQ
+ OpAMD64CMPL
+ OpAMD64CMPW
+ OpAMD64CMPB
+ OpAMD64CMPQconst
+ OpAMD64CMPLconst
+ OpAMD64CMPWconst
+ OpAMD64CMPBconst
+ OpAMD64UCOMISS
+ OpAMD64UCOMISD
+ OpAMD64TESTQ
+ OpAMD64TESTL
+ OpAMD64TESTW
+ OpAMD64TESTB
+ OpAMD64TESTQconst
+ OpAMD64TESTLconst
+ OpAMD64TESTWconst
+ OpAMD64TESTBconst
+ OpAMD64SHLQ
+ OpAMD64SHLL
+ OpAMD64SHLW
+ OpAMD64SHLB
+ OpAMD64SHLQconst
+ OpAMD64SHLLconst
+ OpAMD64SHLWconst
+ OpAMD64SHLBconst
+ OpAMD64SHRQ
+ OpAMD64SHRL
+ OpAMD64SHRW
+ OpAMD64SHRB
+ OpAMD64SHRQconst
+ OpAMD64SHRLconst
+ OpAMD64SHRWconst
+ OpAMD64SHRBconst
+ OpAMD64SARQ
+ OpAMD64SARL
+ OpAMD64SARW
+ OpAMD64SARB
+ OpAMD64SARQconst
+ OpAMD64SARLconst
+ OpAMD64SARWconst
+ OpAMD64SARBconst
+ OpAMD64ROLQconst
+ OpAMD64ROLLconst
+ OpAMD64ROLWconst
+ OpAMD64ROLBconst
+ OpAMD64NEGQ
+ OpAMD64NEGL
+ OpAMD64NEGW
+ OpAMD64NEGB
+ OpAMD64NOTQ
+ OpAMD64NOTL
+ OpAMD64NOTW
+ OpAMD64NOTB
+ OpAMD64SQRTSD
+ OpAMD64SBBQcarrymask
+ OpAMD64SBBLcarrymask
+ OpAMD64SETEQ
+ OpAMD64SETNE
+ OpAMD64SETL
+ OpAMD64SETLE
+ OpAMD64SETG
+ OpAMD64SETGE
+ OpAMD64SETB
+ OpAMD64SETBE
+ OpAMD64SETA
+ OpAMD64SETAE
+ OpAMD64SETEQF
+ OpAMD64SETNEF
+ OpAMD64SETORD
+ OpAMD64SETNAN
+ OpAMD64SETGF
+ OpAMD64SETGEF
+ OpAMD64MOVBQSX
+ OpAMD64MOVBQZX
+ OpAMD64MOVWQSX
+ OpAMD64MOVWQZX
+ OpAMD64MOVLQSX
+ OpAMD64MOVLQZX
+ OpAMD64MOVBconst
+ OpAMD64MOVWconst
+ OpAMD64MOVLconst
+ OpAMD64MOVQconst
+ OpAMD64CVTTSD2SL
+ OpAMD64CVTTSD2SQ
+ OpAMD64CVTTSS2SL
+ OpAMD64CVTTSS2SQ
+ OpAMD64CVTSL2SS
+ OpAMD64CVTSL2SD
+ OpAMD64CVTSQ2SS
+ OpAMD64CVTSQ2SD
+ OpAMD64CVTSD2SS
+ OpAMD64CVTSS2SD
+ OpAMD64PXOR
+ OpAMD64LEAQ
+ OpAMD64LEAQ1
+ OpAMD64LEAQ2
+ OpAMD64LEAQ4
+ OpAMD64LEAQ8
+ OpAMD64MOVBload
+ OpAMD64MOVBQSXload
+ OpAMD64MOVBQZXload
+ OpAMD64MOVWload
+ OpAMD64MOVWQSXload
+ OpAMD64MOVWQZXload
+ OpAMD64MOVLload
+ OpAMD64MOVLQSXload
+ OpAMD64MOVLQZXload
+ OpAMD64MOVQload
+ OpAMD64MOVBstore
+ OpAMD64MOVWstore
+ OpAMD64MOVLstore
+ OpAMD64MOVQstore
+ OpAMD64MOVOload
+ OpAMD64MOVOstore
+ OpAMD64MOVBloadidx1
+ OpAMD64MOVWloadidx2
+ OpAMD64MOVLloadidx4
+ OpAMD64MOVQloadidx8
+ OpAMD64MOVBstoreidx1
+ OpAMD64MOVWstoreidx2
+ OpAMD64MOVLstoreidx4
+ OpAMD64MOVQstoreidx8
+ OpAMD64MOVBstoreconst
+ OpAMD64MOVWstoreconst
+ OpAMD64MOVLstoreconst
+ OpAMD64MOVQstoreconst
+ OpAMD64MOVBstoreconstidx1
+ OpAMD64MOVWstoreconstidx2
+ OpAMD64MOVLstoreconstidx4
+ OpAMD64MOVQstoreconstidx8
+ OpAMD64DUFFZERO
+ OpAMD64MOVOconst
+ OpAMD64REPSTOSQ
+ OpAMD64CALLstatic
+ OpAMD64CALLclosure
+ OpAMD64CALLdefer
+ OpAMD64CALLgo
+ OpAMD64CALLinter
+ OpAMD64DUFFCOPY
+ OpAMD64REPMOVSQ
+ OpAMD64InvertFlags
+ OpAMD64LoweredGetG
+ OpAMD64LoweredGetClosurePtr
+ OpAMD64LoweredNilCheck
+ OpAMD64MOVQconvert
+ OpAMD64FlagEQ
+ OpAMD64FlagLT_ULT
+ OpAMD64FlagLT_UGT
+ OpAMD64FlagGT_UGT
+ OpAMD64FlagGT_ULT
+
+ OpAdd8
+ OpAdd16
+ OpAdd32
+ OpAdd64
+ OpAddPtr
+ OpAdd32F
+ OpAdd64F
+ OpSub8
+ OpSub16
+ OpSub32
+ OpSub64
+ OpSubPtr
+ OpSub32F
+ OpSub64F
+ OpMul8
+ OpMul16
+ OpMul32
+ OpMul64
+ OpMul32F
+ OpMul64F
+ OpDiv32F
+ OpDiv64F
+ OpHmul8
+ OpHmul8u
+ OpHmul16
+ OpHmul16u
+ OpHmul32
+ OpHmul32u
+ OpHmul64
+ OpHmul64u
+ OpAvg64u
+ OpDiv8
+ OpDiv8u
+ OpDiv16
+ OpDiv16u
+ OpDiv32
+ OpDiv32u
+ OpDiv64
+ OpDiv64u
+ OpMod8
+ OpMod8u
+ OpMod16
+ OpMod16u
+ OpMod32
+ OpMod32u
+ OpMod64
+ OpMod64u
+ OpAnd8
+ OpAnd16
+ OpAnd32
+ OpAnd64
+ OpOr8
+ OpOr16
+ OpOr32
+ OpOr64
+ OpXor8
+ OpXor16
+ OpXor32
+ OpXor64
+ OpLsh8x8
+ OpLsh8x16
+ OpLsh8x32
+ OpLsh8x64
+ OpLsh16x8
+ OpLsh16x16
+ OpLsh16x32
+ OpLsh16x64
+ OpLsh32x8
+ OpLsh32x16
+ OpLsh32x32
+ OpLsh32x64
+ OpLsh64x8
+ OpLsh64x16
+ OpLsh64x32
+ OpLsh64x64
+ OpRsh8x8
+ OpRsh8x16
+ OpRsh8x32
+ OpRsh8x64
+ OpRsh16x8
+ OpRsh16x16
+ OpRsh16x32
+ OpRsh16x64
+ OpRsh32x8
+ OpRsh32x16
+ OpRsh32x32
+ OpRsh32x64
+ OpRsh64x8
+ OpRsh64x16
+ OpRsh64x32
+ OpRsh64x64
+ OpRsh8Ux8
+ OpRsh8Ux16
+ OpRsh8Ux32
+ OpRsh8Ux64
+ OpRsh16Ux8
+ OpRsh16Ux16
+ OpRsh16Ux32
+ OpRsh16Ux64
+ OpRsh32Ux8
+ OpRsh32Ux16
+ OpRsh32Ux32
+ OpRsh32Ux64
+ OpRsh64Ux8
+ OpRsh64Ux16
+ OpRsh64Ux32
+ OpRsh64Ux64
+ OpLrot8
+ OpLrot16
+ OpLrot32
+ OpLrot64
+ OpEq8
+ OpEq16
+ OpEq32
+ OpEq64
+ OpEqPtr
+ OpEqInter
+ OpEqSlice
+ OpEq32F
+ OpEq64F
+ OpNeq8
+ OpNeq16
+ OpNeq32
+ OpNeq64
+ OpNeqPtr
+ OpNeqInter
+ OpNeqSlice
+ OpNeq32F
+ OpNeq64F
+ OpLess8
+ OpLess8U
+ OpLess16
+ OpLess16U
+ OpLess32
+ OpLess32U
+ OpLess64
+ OpLess64U
+ OpLess32F
+ OpLess64F
+ OpLeq8
+ OpLeq8U
+ OpLeq16
+ OpLeq16U
+ OpLeq32
+ OpLeq32U
+ OpLeq64
+ OpLeq64U
+ OpLeq32F
+ OpLeq64F
+ OpGreater8
+ OpGreater8U
+ OpGreater16
+ OpGreater16U
+ OpGreater32
+ OpGreater32U
+ OpGreater64
+ OpGreater64U
+ OpGreater32F
+ OpGreater64F
+ OpGeq8
+ OpGeq8U
+ OpGeq16
+ OpGeq16U
+ OpGeq32
+ OpGeq32U
+ OpGeq64
+ OpGeq64U
+ OpGeq32F
+ OpGeq64F
+ OpNot
+ OpNeg8
+ OpNeg16
+ OpNeg32
+ OpNeg64
+ OpNeg32F
+ OpNeg64F
+ OpCom8
+ OpCom16
+ OpCom32
+ OpCom64
+ OpSqrt
+ OpPhi
+ OpCopy
+ OpConvert
+ OpConstBool
+ OpConstString
+ OpConstNil
+ OpConst8
+ OpConst16
+ OpConst32
+ OpConst64
+ OpConst32F
+ OpConst64F
+ OpConstInterface
+ OpConstSlice
+ OpInitMem
+ OpArg
+ OpAddr
+ OpSP
+ OpSB
+ OpFunc
+ OpLoad
+ OpStore
+ OpMove
+ OpZero
+ OpClosureCall
+ OpStaticCall
+ OpDeferCall
+ OpGoCall
+ OpInterCall
+ OpSignExt8to16
+ OpSignExt8to32
+ OpSignExt8to64
+ OpSignExt16to32
+ OpSignExt16to64
+ OpSignExt32to64
+ OpZeroExt8to16
+ OpZeroExt8to32
+ OpZeroExt8to64
+ OpZeroExt16to32
+ OpZeroExt16to64
+ OpZeroExt32to64
+ OpTrunc16to8
+ OpTrunc32to8
+ OpTrunc32to16
+ OpTrunc64to8
+ OpTrunc64to16
+ OpTrunc64to32
+ OpCvt32to32F
+ OpCvt32to64F
+ OpCvt64to32F
+ OpCvt64to64F
+ OpCvt32Fto32
+ OpCvt32Fto64
+ OpCvt64Fto32
+ OpCvt64Fto64
+ OpCvt32Fto64F
+ OpCvt64Fto32F
+ OpIsNonNil
+ OpIsInBounds
+ OpIsSliceInBounds
+ OpNilCheck
+ OpGetG
+ OpGetClosurePtr
+ OpArrayIndex
+ OpPtrIndex
+ OpOffPtr
+ OpSliceMake
+ OpSlicePtr
+ OpSliceLen
+ OpSliceCap
+ OpComplexMake
+ OpComplexReal
+ OpComplexImag
+ OpStringMake
+ OpStringPtr
+ OpStringLen
+ OpIMake
+ OpITab
+ OpIData
+ OpStructMake0
+ OpStructMake1
+ OpStructMake2
+ OpStructMake3
+ OpStructMake4
+ OpStructSelect
+ OpStoreReg
+ OpLoadReg
+ OpFwdRef
+ OpUnknown
+ OpVarDef
+ OpVarKill
+ OpVarLive
+)
+
+var opcodeTable = [...]opInfo{
+ {name: "OpInvalid"},
+
+ {
+ name: "ADDSS",
+ argLen: 2,
+ asm: x86.AADDSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "ADDSD",
+ argLen: 2,
+ asm: x86.AADDSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "SUBSS",
+ argLen: 2,
+ asm: x86.ASUBSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ {1, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ clobbers: 2147483648, // .X15
+ outputs: []regMask{
+ 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ },
+ },
+ {
+ name: "SUBSD",
+ argLen: 2,
+ asm: x86.ASUBSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ {1, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ clobbers: 2147483648, // .X15
+ outputs: []regMask{
+ 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ },
+ },
+ {
+ name: "MULSS",
+ argLen: 2,
+ asm: x86.AMULSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MULSD",
+ argLen: 2,
+ asm: x86.AMULSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "DIVSS",
+ argLen: 2,
+ asm: x86.ADIVSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ {1, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ clobbers: 2147483648, // .X15
+ outputs: []regMask{
+ 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ },
+ },
+ {
+ name: "DIVSD",
+ argLen: 2,
+ asm: x86.ADIVSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ {1, 2147418112}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ clobbers: 2147483648, // .X15
+ outputs: []regMask{
+ 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14
+ },
+ },
+ },
+ {
+ name: "MOVSSload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSDload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSSconst",
+ auxType: auxFloat,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVSS,
+ reg: regInfo{
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSDconst",
+ auxType: auxFloat,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVSD,
+ reg: regInfo{
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSSloadidx4",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSDloadidx8",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVSSstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVSDstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVSSstoreidx4",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVSS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVSDstoreidx8",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "ADDQ",
+ argLen: 2,
+ asm: x86.AADDQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDL",
+ argLen: 2,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDW",
+ argLen: 2,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDB",
+ argLen: 2,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AADDQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ADDBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AADDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBQ",
+ argLen: 2,
+ asm: x86.ASUBQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBL",
+ argLen: 2,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBW",
+ argLen: 2,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBB",
+ argLen: 2,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ASUBQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SUBBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ASUBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULQ",
+ argLen: 2,
+ asm: x86.AIMULQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULL",
+ argLen: 2,
+ asm: x86.AIMULL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULW",
+ argLen: 2,
+ asm: x86.AIMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULB",
+ argLen: 2,
+ asm: x86.AIMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AIMULQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AIMULL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AIMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MULBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AIMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "HMULQ",
+ argLen: 2,
+ asm: x86.AIMULQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULL",
+ argLen: 2,
+ asm: x86.AIMULL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULW",
+ argLen: 2,
+ asm: x86.AIMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULB",
+ argLen: 2,
+ asm: x86.AIMULB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULQU",
+ argLen: 2,
+ asm: x86.AMULQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULLU",
+ argLen: 2,
+ asm: x86.AMULL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULWU",
+ argLen: 2,
+ asm: x86.AMULW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "HMULBU",
+ argLen: 2,
+ asm: x86.AMULB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "AVGQU",
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "DIVQ",
+ argLen: 2,
+ asm: x86.AIDIVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "DIVL",
+ argLen: 2,
+ asm: x86.AIDIVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "DIVW",
+ argLen: 2,
+ asm: x86.AIDIVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "DIVQU",
+ argLen: 2,
+ asm: x86.ADIVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "DIVLU",
+ argLen: 2,
+ asm: x86.ADIVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "DIVWU",
+ argLen: 2,
+ asm: x86.ADIVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934596, // .DX .FLAGS
+ outputs: []regMask{
+ 1, // .AX
+ },
+ },
+ },
+ {
+ name: "MODQ",
+ argLen: 2,
+ asm: x86.AIDIVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "MODL",
+ argLen: 2,
+ asm: x86.AIDIVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "MODW",
+ argLen: 2,
+ asm: x86.AIDIVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "MODQU",
+ argLen: 2,
+ asm: x86.ADIVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "MODLU",
+ argLen: 2,
+ asm: x86.ADIVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "MODWU",
+ argLen: 2,
+ asm: x86.ADIVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 1}, // .AX
+ {1, 65531}, // .AX .CX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "ANDQ",
+ argLen: 2,
+ asm: x86.AANDQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDL",
+ argLen: 2,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDW",
+ argLen: 2,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDB",
+ argLen: 2,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AANDQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ANDBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AANDL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORQ",
+ argLen: 2,
+ asm: x86.AORQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORL",
+ argLen: 2,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORW",
+ argLen: 2,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORB",
+ argLen: 2,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AORQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ORBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORQ",
+ argLen: 2,
+ asm: x86.AXORQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORL",
+ argLen: 2,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORW",
+ argLen: 2,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORB",
+ argLen: 2,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AXORQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "XORBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AXORL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CMPQ",
+ argLen: 2,
+ asm: x86.ACMPQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPL",
+ argLen: 2,
+ asm: x86.ACMPL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPW",
+ argLen: 2,
+ asm: x86.ACMPW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPB",
+ argLen: 2,
+ asm: x86.ACMPB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ACMPQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ACMPL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ACMPW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "CMPBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ACMPB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "UCOMISS",
+ argLen: 2,
+ asm: x86.AUCOMISS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "UCOMISD",
+ argLen: 2,
+ asm: x86.AUCOMISD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTQ",
+ argLen: 2,
+ asm: x86.ATESTQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTL",
+ argLen: 2,
+ asm: x86.ATESTL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTW",
+ argLen: 2,
+ asm: x86.ATESTW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTB",
+ argLen: 2,
+ asm: x86.ATESTB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ATESTQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ATESTL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ATESTW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "TESTBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ATESTB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 8589934592, // .FLAGS
+ },
+ },
+ },
+ {
+ name: "SHLQ",
+ argLen: 2,
+ asm: x86.ASHLQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLL",
+ argLen: 2,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLW",
+ argLen: 2,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLB",
+ argLen: 2,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ASHLQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHLBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ASHLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRQ",
+ argLen: 2,
+ asm: x86.ASHRQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRL",
+ argLen: 2,
+ asm: x86.ASHRL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRW",
+ argLen: 2,
+ asm: x86.ASHRW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRB",
+ argLen: 2,
+ asm: x86.ASHRB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ASHRQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ASHRL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ASHRW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SHRBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ASHRB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARQ",
+ argLen: 2,
+ asm: x86.ASARQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARL",
+ argLen: 2,
+ asm: x86.ASARL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARW",
+ argLen: 2,
+ asm: x86.ASARW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARB",
+ argLen: 2,
+ asm: x86.ASARB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 2}, // .CX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.ASARQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.ASARL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.ASARW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SARBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.ASARB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ROLQconst",
+ auxType: auxInt64,
+ argLen: 1,
+ asm: x86.AROLQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ROLLconst",
+ auxType: auxInt32,
+ argLen: 1,
+ asm: x86.AROLL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ROLWconst",
+ auxType: auxInt16,
+ argLen: 1,
+ asm: x86.AROLW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "ROLBconst",
+ auxType: auxInt8,
+ argLen: 1,
+ asm: x86.AROLB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NEGQ",
+ argLen: 1,
+ asm: x86.ANEGQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NEGL",
+ argLen: 1,
+ asm: x86.ANEGL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NEGW",
+ argLen: 1,
+ asm: x86.ANEGL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NEGB",
+ argLen: 1,
+ asm: x86.ANEGL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NOTQ",
+ argLen: 1,
+ asm: x86.ANOTQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NOTL",
+ argLen: 1,
+ asm: x86.ANOTL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NOTW",
+ argLen: 1,
+ asm: x86.ANOTL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "NOTB",
+ argLen: 1,
+ asm: x86.ANOTL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SQRTSD",
+ argLen: 1,
+ asm: x86.ASQRTSD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "SBBQcarrymask",
+ argLen: 1,
+ asm: x86.ASBBQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SBBLcarrymask",
+ argLen: 1,
+ asm: x86.ASBBL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETEQ",
+ argLen: 1,
+ asm: x86.ASETEQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETNE",
+ argLen: 1,
+ asm: x86.ASETNE,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETL",
+ argLen: 1,
+ asm: x86.ASETLT,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETLE",
+ argLen: 1,
+ asm: x86.ASETLE,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETG",
+ argLen: 1,
+ asm: x86.ASETGT,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETGE",
+ argLen: 1,
+ asm: x86.ASETGE,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETB",
+ argLen: 1,
+ asm: x86.ASETCS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETBE",
+ argLen: 1,
+ asm: x86.ASETLS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETA",
+ argLen: 1,
+ asm: x86.ASETHI,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETAE",
+ argLen: 1,
+ asm: x86.ASETCC,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETEQF",
+ argLen: 1,
+ asm: x86.ASETEQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETNEF",
+ argLen: 1,
+ asm: x86.ASETNE,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ clobbers: 8589934593, // .AX .FLAGS
+ outputs: []regMask{
+ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETORD",
+ argLen: 1,
+ asm: x86.ASETPC,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETNAN",
+ argLen: 1,
+ asm: x86.ASETPS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETGF",
+ argLen: 1,
+ asm: x86.ASETHI,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "SETGEF",
+ argLen: 1,
+ asm: x86.ASETCC,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 8589934592}, // .FLAGS
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBQSX",
+ argLen: 1,
+ asm: x86.AMOVBQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBQZX",
+ argLen: 1,
+ asm: x86.AMOVBQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWQSX",
+ argLen: 1,
+ asm: x86.AMOVWQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWQZX",
+ argLen: 1,
+ asm: x86.AMOVWQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLQSX",
+ argLen: 1,
+ asm: x86.AMOVLQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLQZX",
+ argLen: 1,
+ asm: x86.AMOVLQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBconst",
+ auxType: auxInt8,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVB,
+ reg: regInfo{
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWconst",
+ auxType: auxInt16,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVW,
+ reg: regInfo{
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLconst",
+ auxType: auxInt32,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVQconst",
+ auxType: auxInt64,
+ argLen: 0,
+ rematerializeable: true,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CVTTSD2SL",
+ argLen: 1,
+ asm: x86.ACVTTSD2SL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CVTTSD2SQ",
+ argLen: 1,
+ asm: x86.ACVTTSD2SQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CVTTSS2SL",
+ argLen: 1,
+ asm: x86.ACVTTSS2SL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CVTTSS2SQ",
+ argLen: 1,
+ asm: x86.ACVTTSS2SQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "CVTSL2SS",
+ argLen: 1,
+ asm: x86.ACVTSL2SS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "CVTSL2SD",
+ argLen: 1,
+ asm: x86.ACVTSL2SD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "CVTSQ2SS",
+ argLen: 1,
+ asm: x86.ACVTSQ2SS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "CVTSQ2SD",
+ argLen: 1,
+ asm: x86.ACVTSQ2SD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "CVTSD2SS",
+ argLen: 1,
+ asm: x86.ACVTSD2SS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "CVTSS2SD",
+ argLen: 1,
+ asm: x86.ACVTSS2SD,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "PXOR",
+ argLen: 2,
+ asm: x86.APXOR,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "LEAQ",
+ auxType: auxSymOff,
+ argLen: 1,
+ rematerializeable: true,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "LEAQ1",
+ auxType: auxSymOff,
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "LEAQ2",
+ auxType: auxSymOff,
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "LEAQ4",
+ auxType: auxSymOff,
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "LEAQ8",
+ auxType: auxSymOff,
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVBLZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBQSXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVBQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBQZXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVBQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVWLZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWQSXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVWQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWQZXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVWQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLQSXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVLQSX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLQZXload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVLQZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVQload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVWstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVLstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVQstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVOload",
+ auxType: auxSymOff,
+ argLen: 2,
+ asm: x86.AMOVUPS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "MOVOstore",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVUPS,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVBloadidx1",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVBLZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVWloadidx2",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVWLZX,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVLloadidx4",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVQloadidx8",
+ auxType: auxSymOff,
+ argLen: 3,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "MOVBstoreidx1",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVWstoreidx2",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVLstoreidx4",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVQstoreidx8",
+ auxType: auxSymOff,
+ argLen: 4,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {2, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVBstoreconst",
+ auxType: auxSymValAndOff,
+ argLen: 2,
+ asm: x86.AMOVB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVWstoreconst",
+ auxType: auxSymValAndOff,
+ argLen: 2,
+ asm: x86.AMOVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVLstoreconst",
+ auxType: auxSymValAndOff,
+ argLen: 2,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVQstoreconst",
+ auxType: auxSymValAndOff,
+ argLen: 2,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVBstoreconstidx1",
+ auxType: auxSymValAndOff,
+ argLen: 3,
+ asm: x86.AMOVB,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVWstoreconstidx2",
+ auxType: auxSymValAndOff,
+ argLen: 3,
+ asm: x86.AMOVW,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVLstoreconstidx4",
+ auxType: auxSymValAndOff,
+ argLen: 3,
+ asm: x86.AMOVL,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "MOVQstoreconstidx8",
+ auxType: auxSymValAndOff,
+ argLen: 3,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB
+ },
+ },
+ },
+ {
+ name: "DUFFZERO",
+ auxType: auxInt64,
+ argLen: 3,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 128}, // .DI
+ {1, 65536}, // .X0
+ },
+ clobbers: 8589934720, // .DI .FLAGS
+ },
+ },
+ {
+ name: "MOVOconst",
+ argLen: 0,
+ rematerializeable: true,
+ reg: regInfo{
+ outputs: []regMask{
+ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15
+ },
+ },
+ },
+ {
+ name: "REPSTOSQ",
+ argLen: 4,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 128}, // .DI
+ {1, 2}, // .CX
+ {2, 1}, // .AX
+ },
+ clobbers: 8589934722, // .CX .DI .FLAGS
+ },
+ },
+ {
+ name: "CALLstatic",
+ auxType: auxSymOff,
+ argLen: 1,
+ reg: regInfo{
+ clobbers: 12884901871, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 .FLAGS
+ },
+ },
+ {
+ name: "CALLclosure",
+ auxType: auxInt64,
+ argLen: 3,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {1, 4}, // .DX
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 12884901871, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 .FLAGS
+ },
+ },
+ {
+ name: "CALLdefer",
+ auxType: auxInt64,
+ argLen: 1,
+ reg: regInfo{
+ clobbers: 12884901871, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 .FLAGS
+ },
+ },
+ {
+ name: "CALLgo",
+ auxType: auxInt64,
+ argLen: 1,
+ reg: regInfo{
+ clobbers: 12884901871, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 .FLAGS
+ },
+ },
+ {
+ name: "CALLinter",
+ auxType: auxInt64,
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 12884901871, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 .FLAGS
+ },
+ },
+ {
+ name: "DUFFCOPY",
+ auxType: auxInt64,
+ argLen: 3,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 128}, // .DI
+ {1, 64}, // .SI
+ },
+ clobbers: 8590000320, // .SI .DI .X0 .FLAGS
+ },
+ },
+ {
+ name: "REPMOVSQ",
+ argLen: 4,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 128}, // .DI
+ {1, 64}, // .SI
+ {2, 2}, // .CX
+ },
+ clobbers: 194, // .CX .SI .DI
+ },
+ },
+ {
+ name: "InvertFlags",
+ argLen: 1,
+ reg: regInfo{},
+ },
+ {
+ name: "LoweredGetG",
+ argLen: 1,
+ reg: regInfo{
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "LoweredGetClosurePtr",
+ argLen: 0,
+ reg: regInfo{
+ outputs: []regMask{
+ 4, // .DX
+ },
+ },
+ },
+ {
+ name: "LoweredNilCheck",
+ argLen: 2,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ clobbers: 8589934592, // .FLAGS
+ },
+ },
+ {
+ name: "MOVQconvert",
+ argLen: 2,
+ asm: x86.AMOVQ,
+ reg: regInfo{
+ inputs: []inputInfo{
+ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ outputs: []regMask{
+ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15
+ },
+ },
+ },
+ {
+ name: "FlagEQ",
+ argLen: 0,
+ reg: regInfo{},
+ },
+ {
+ name: "FlagLT_ULT",
+ argLen: 0,
+ reg: regInfo{},
+ },
+ {
+ name: "FlagLT_UGT",
+ argLen: 0,
+ reg: regInfo{},
+ },
+ {
+ name: "FlagGT_UGT",
+ argLen: 0,
+ reg: regInfo{},
+ },
+ {
+ name: "FlagGT_ULT",
+ argLen: 0,
+ reg: regInfo{},
+ },
+
+ {
+ name: "Add8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Add16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Add32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Add64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "AddPtr",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Add32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Add64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "SubPtr",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Sub64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mul8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Mul16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Mul32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Mul64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Mul32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mul64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul8u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul16u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul32u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Hmul64u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Avg64u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div8u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div16u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div32u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Div64u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod8u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod16u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod32u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Mod64u",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "And8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "And16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "And32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "And64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Or8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Or16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Or32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Or64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Xor8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Xor16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Xor32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Xor64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Lsh8x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh8x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh8x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh8x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh16x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh16x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh16x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh16x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh32x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh32x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh32x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh32x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh64x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh64x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh64x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lsh64x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64x8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64x16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64x32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64x64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8Ux8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8Ux16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8Ux32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh8Ux64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16Ux8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16Ux16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16Ux32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh16Ux64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32Ux8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32Ux16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32Ux32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh32Ux64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64Ux8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64Ux16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64Ux32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Rsh64Ux64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Lrot8",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Lrot16",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Lrot32",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Lrot64",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Eq8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Eq16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Eq32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Eq64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "EqPtr",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "EqInter",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "EqSlice",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Eq32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Eq64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Neq8",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Neq16",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Neq32",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "Neq64",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "NeqPtr",
+ argLen: 2,
+ commutative: true,
+ generic: true,
+ },
+ {
+ name: "NeqInter",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "NeqSlice",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Neq32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Neq64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less8U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less16U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less32U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less64U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Less64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq8U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq16U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq32U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq64U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Leq64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater8U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater16U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater32U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater64U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Greater64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq8",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq8U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq16",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq16U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq32",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq32U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq64",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq64U",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq32F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Geq64F",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Not",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg8",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg32F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Neg64F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Com8",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Com16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Com32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Com64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Sqrt",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Phi",
+ argLen: -1,
+ generic: true,
+ },
+ {
+ name: "Copy",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Convert",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "ConstBool",
+ auxType: auxBool,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "ConstString",
+ auxType: auxString,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "ConstNil",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const8",
+ auxType: auxInt8,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const16",
+ auxType: auxInt16,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const32",
+ auxType: auxInt32,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const64",
+ auxType: auxInt64,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const32F",
+ auxType: auxFloat,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Const64F",
+ auxType: auxFloat,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "ConstInterface",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "ConstSlice",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "InitMem",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Arg",
+ auxType: auxSymOff,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Addr",
+ auxType: auxSym,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SP",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "SB",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Func",
+ auxType: auxSym,
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Load",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "Store",
+ auxType: auxInt64,
+ argLen: 3,
+ generic: true,
+ },
+ {
+ name: "Move",
+ auxType: auxInt64,
+ argLen: 3,
+ generic: true,
+ },
+ {
+ name: "Zero",
+ auxType: auxInt64,
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "ClosureCall",
+ auxType: auxInt64,
+ argLen: 3,
+ generic: true,
+ },
+ {
+ name: "StaticCall",
+ auxType: auxSymOff,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "DeferCall",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "GoCall",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "InterCall",
+ auxType: auxInt64,
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "SignExt8to16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SignExt8to32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SignExt8to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SignExt16to32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SignExt16to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SignExt32to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt8to16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt8to32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt8to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt16to32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt16to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ZeroExt32to64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc16to8",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc32to8",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc32to16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc64to8",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc64to16",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Trunc64to32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt32to32F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt32to64F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt64to32F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt64to64F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt32Fto32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt32Fto64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt64Fto32",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt64Fto64",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt32Fto64F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "Cvt64Fto32F",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "IsNonNil",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "IsInBounds",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "IsSliceInBounds",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "NilCheck",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "GetG",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "GetClosurePtr",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "ArrayIndex",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "PtrIndex",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "OffPtr",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SliceMake",
+ argLen: 3,
+ generic: true,
+ },
+ {
+ name: "SlicePtr",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SliceLen",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "SliceCap",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ComplexMake",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "ComplexReal",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "ComplexImag",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "StringMake",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "StringPtr",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "StringLen",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "IMake",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "ITab",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "IData",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "StructMake0",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "StructMake1",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "StructMake2",
+ argLen: 2,
+ generic: true,
+ },
+ {
+ name: "StructMake3",
+ argLen: 3,
+ generic: true,
+ },
+ {
+ name: "StructMake4",
+ argLen: 4,
+ generic: true,
+ },
+ {
+ name: "StructSelect",
+ auxType: auxInt64,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "StoreReg",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "LoadReg",
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "FwdRef",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "Unknown",
+ argLen: 0,
+ generic: true,
+ },
+ {
+ name: "VarDef",
+ auxType: auxSym,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "VarKill",
+ auxType: auxSym,
+ argLen: 1,
+ generic: true,
+ },
+ {
+ name: "VarLive",
+ auxType: auxSym,
+ argLen: 1,
+ generic: true,
+ },
+}
+
+func (o Op) Asm() int { return opcodeTable[o].asm }
+func (o Op) String() string { return opcodeTable[o].name }
diff --git a/src/cmd/compile/internal/ssa/opt.go b/src/cmd/compile/internal/ssa/opt.go
new file mode 100644
index 0000000..6e91fd7
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/opt.go
@@ -0,0 +1,10 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// machine-independent optimization
+func opt(f *Func) {
+ applyRewrite(f, rewriteBlockgeneric, rewriteValuegeneric)
+}
diff --git a/src/cmd/compile/internal/ssa/passbm_test.go b/src/cmd/compile/internal/ssa/passbm_test.go
new file mode 100644
index 0000000..8dff17a
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/passbm_test.go
@@ -0,0 +1,101 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package ssa
+
+import (
+ "fmt"
+ "testing"
+)
+
+const (
+ blockCount = 1000
+ passCount = 15000
+)
+
+type passFunc func(*Func)
+
+func BenchmarkDSEPass(b *testing.B) { benchFnPass(b, dse, blockCount, genFunction) }
+func BenchmarkDSEPassBlock(b *testing.B) { benchFnBlock(b, dse, genFunction) }
+func BenchmarkCSEPass(b *testing.B) { benchFnPass(b, cse, blockCount, genFunction) }
+func BenchmarkCSEPassBlock(b *testing.B) { benchFnBlock(b, cse, genFunction) }
+func BenchmarkDeadcodePass(b *testing.B) { benchFnPass(b, deadcode, blockCount, genFunction) }
+func BenchmarkDeadcodePassBlock(b *testing.B) { benchFnBlock(b, deadcode, genFunction) }
+
+func multi(f *Func) {
+ cse(f)
+ dse(f)
+ deadcode(f)
+}
+func BenchmarkMultiPass(b *testing.B) { benchFnPass(b, multi, blockCount, genFunction) }
+func BenchmarkMultiPassBlock(b *testing.B) { benchFnBlock(b, multi, genFunction) }
+
+// benchFnPass runs passFunc b.N times across a single function.
+func benchFnPass(b *testing.B, fn passFunc, size int, bg blockGen) {
+ b.ReportAllocs()
+ c := NewConfig("amd64", DummyFrontend{b}, nil, true)
+ fun := Fun(c, "entry", bg(size)...)
+
+ CheckFunc(fun.f)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fn(fun.f)
+ b.StopTimer()
+ CheckFunc(fun.f)
+ b.StartTimer()
+ }
+}
+
+// benchFnPass runs passFunc across a function with b.N blocks.
+func benchFnBlock(b *testing.B, fn passFunc, bg blockGen) {
+ b.ReportAllocs()
+ c := NewConfig("amd64", DummyFrontend{b}, nil, true)
+ fun := Fun(c, "entry", bg(b.N)...)
+
+ CheckFunc(fun.f)
+ b.ResetTimer()
+ for i := 0; i < passCount; i++ {
+ fn(fun.f)
+ }
+ b.StopTimer()
+}
+
+func genFunction(size int) []bloc {
+ var blocs []bloc
+ elemType := &TypeImpl{Size_: 8, Name: "testtype"}
+ ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr", Elem_: elemType} // dummy for testing
+
+ valn := func(s string, m, n int) string { return fmt.Sprintf("%s%d-%d", s, m, n) }
+ blocs = append(blocs,
+ Bloc("entry",
+ Valu(valn("store", 0, 4), OpInitMem, TypeMem, 0, nil),
+ Valu("sb", OpSB, TypeInvalid, 0, nil),
+ Goto(blockn(1)),
+ ),
+ )
+ for i := 1; i < size+1; i++ {
+ blocs = append(blocs, Bloc(blockn(i),
+ Valu(valn("v", i, 0), OpConstBool, TypeBool, 1, nil),
+ Valu(valn("addr", i, 1), OpAddr, ptrType, 0, nil, "sb"),
+ Valu(valn("addr", i, 2), OpAddr, ptrType, 0, nil, "sb"),
+ Valu(valn("addr", i, 3), OpAddr, ptrType, 0, nil, "sb"),
+ Valu(valn("zero", i, 1), OpZero, TypeMem, 8, nil, valn("addr", i, 3),
+ valn("store", i-1, 4)),
+ Valu(valn("store", i, 1), OpStore, TypeMem, 0, nil, valn("addr", i, 1),
+ valn("v", i, 0), valn("zero", i, 1)),
+ Valu(valn("store", i, 2), OpStore, TypeMem, 0, nil, valn("addr", i, 2),
+ valn("v", i, 0), valn("store", i, 1)),
+ Valu(valn("store", i, 3), OpStore, TypeMem, 0, nil, valn("addr", i, 1),
+ valn("v", i, 0), valn("store", i, 2)),
+ Valu(valn("store", i, 4), OpStore, TypeMem, 0, nil, valn("addr", i, 3),
+ valn("v", i, 0), valn("store", i, 3)),
+ Goto(blockn(i+1))))
+ }
+
+ blocs = append(blocs,
+ Bloc(blockn(size+1), Goto("exit")),
+ Bloc("exit", Exit("store0-4")),
+ )
+
+ return blocs
+}
diff --git a/src/cmd/compile/internal/ssa/phielim.go b/src/cmd/compile/internal/ssa/phielim.go
new file mode 100644
index 0000000..d69449e
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/phielim.go
@@ -0,0 +1,68 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// phielim eliminates redundant phi values from f.
+// A phi is redundant if its arguments are all equal. For
+// purposes of counting, ignore the phi itself. Both of
+// these phis are redundant:
+// v = phi(x,x,x)
+// v = phi(x,v,x,v)
+// We repeat this process to also catch situations like:
+// v = phi(x, phi(x, x), phi(x, v))
+// TODO: Can we also simplify cases like:
+// v = phi(v, w, x)
+// w = phi(v, w, x)
+// and would that be useful?
+func phielim(f *Func) {
+ for {
+ change := false
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ copyelimValue(v)
+ change = phielimValue(v) || change
+ }
+ }
+ if !change {
+ break
+ }
+ }
+}
+
+func phielimValue(v *Value) bool {
+ if v.Op != OpPhi {
+ return false
+ }
+
+ // If there are two distinct args of v which
+ // are not v itself, then the phi must remain.
+ // Otherwise, we can replace it with a copy.
+ var w *Value
+ for i, x := range v.Args {
+ if b := v.Block.Preds[i]; b.Kind == BlockFirst && b.Succs[1] == v.Block {
+ // This branch is never taken so we can just eliminate it.
+ continue
+ }
+ if x == v {
+ continue
+ }
+ if x == w {
+ continue
+ }
+ if w != nil {
+ return false
+ }
+ w = x
+ }
+
+ if w == nil {
+ // v references only itself. It must be in
+ // a dead code loop. Don't bother modifying it.
+ return false
+ }
+ v.Op = OpCopy
+ v.SetArgs1(w)
+ return true
+}
diff --git a/src/cmd/compile/internal/ssa/phiopt.go b/src/cmd/compile/internal/ssa/phiopt.go
new file mode 100644
index 0000000..fb17727
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/phiopt.go
@@ -0,0 +1,86 @@
+package ssa
+
+// phiopt eliminates boolean Phis based on the previous if.
+//
+// Main use case is to transform:
+// x := false
+// if b {
+// x = true
+// }
+// into x = b.
+//
+// In SSA code this appears as
+//
+// b0
+// If b -> b1 b2
+// b1
+// Plain -> b2
+// b2
+// x = (OpPhi (ConstBool [true]) (ConstBool [false]))
+//
+// In this case we can replace x with a copy of b.
+func phiopt(f *Func) {
+ for _, b := range f.Blocks {
+ if len(b.Preds) != 2 || len(b.Values) == 0 {
+ continue
+ }
+
+ pb0, b0 := b, b.Preds[0]
+ for b0.Kind != BlockIf && len(b0.Preds) == 1 {
+ pb0, b0 = b0, b0.Preds[0]
+ }
+ if b0.Kind != BlockIf {
+ continue
+ }
+ pb1, b1 := b, b.Preds[1]
+ for b1.Kind != BlockIf && len(b1.Preds) == 1 {
+ pb1, b1 = b1, b1.Preds[0]
+ }
+ if b1 != b0 {
+ continue
+ }
+ // b0 is the if block giving the boolean value.
+
+ var reverse bool
+ if b0.Succs[0] == pb0 && b0.Succs[1] == pb1 {
+ reverse = false
+ } else if b0.Succs[0] == pb1 && b0.Succs[1] == pb0 {
+ reverse = true
+ } else {
+ b.Fatalf("invalid predecessors\n")
+ }
+
+ for _, v := range b.Values {
+ if v.Op != OpPhi || !v.Type.IsBoolean() || v.Args[0].Op != OpConstBool || v.Args[1].Op != OpConstBool {
+ continue
+ }
+
+ ok, isCopy := false, false
+ if v.Args[0].AuxInt == 1 && v.Args[1].AuxInt == 0 {
+ ok, isCopy = true, !reverse
+ } else if v.Args[0].AuxInt == 0 && v.Args[1].AuxInt == 1 {
+ ok, isCopy = true, reverse
+ }
+
+ // (Phi (ConstBool [x]) (ConstBool [x])) is already handled by opt / phielim.
+
+ if ok && isCopy {
+ if f.pass.debug > 0 {
+ f.Config.Warnl(int(b.Line), "converted OpPhi to OpCopy")
+ }
+ v.reset(OpCopy)
+ v.AddArg(b0.Control)
+ continue
+ }
+ if ok && !isCopy {
+ if f.pass.debug > 0 {
+ f.Config.Warnl(int(b.Line), "converted OpPhi to OpNot")
+ }
+ v.reset(OpNot)
+ v.AddArg(b0.Control)
+ continue
+ }
+ }
+ }
+
+}
diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go
new file mode 100644
index 0000000..c6f84ab
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/print.go
@@ -0,0 +1,149 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+)
+
+func printFunc(f *Func) {
+ f.Logf("%s", f)
+}
+
+func (f *Func) String() string {
+ var buf bytes.Buffer
+ p := stringFuncPrinter{w: &buf}
+ fprintFunc(p, f)
+ return buf.String()
+}
+
+type funcPrinter interface {
+ header(f *Func)
+ startBlock(b *Block, reachable bool)
+ endBlock(b *Block)
+ value(v *Value, live bool)
+ startDepCycle()
+ endDepCycle()
+ named(n LocalSlot, vals []*Value)
+}
+
+type stringFuncPrinter struct {
+ w io.Writer
+}
+
+func (p stringFuncPrinter) header(f *Func) {
+ fmt.Fprint(p.w, f.Name)
+ fmt.Fprint(p.w, " ")
+ fmt.Fprintln(p.w, f.Type)
+}
+
+func (p stringFuncPrinter) startBlock(b *Block, reachable bool) {
+ fmt.Fprintf(p.w, " b%d:", b.ID)
+ if len(b.Preds) > 0 {
+ io.WriteString(p.w, " <-")
+ for _, pred := range b.Preds {
+ fmt.Fprintf(p.w, " b%d", pred.ID)
+ }
+ }
+ if !reachable {
+ fmt.Fprint(p.w, " DEAD")
+ }
+ io.WriteString(p.w, "\n")
+}
+
+func (p stringFuncPrinter) endBlock(b *Block) {
+ fmt.Fprintln(p.w, " "+b.LongString())
+}
+
+func (p stringFuncPrinter) value(v *Value, live bool) {
+ fmt.Fprint(p.w, " ")
+ //fmt.Fprint(p.w, v.Block.Func.Config.fe.Line(v.Line))
+ //fmt.Fprint(p.w, ": ")
+ fmt.Fprint(p.w, v.LongString())
+ if !live {
+ fmt.Fprint(p.w, " DEAD")
+ }
+ fmt.Fprintln(p.w)
+}
+
+func (p stringFuncPrinter) startDepCycle() {
+ fmt.Fprintln(p.w, "dependency cycle!")
+}
+
+func (p stringFuncPrinter) endDepCycle() {}
+
+func (p stringFuncPrinter) named(n LocalSlot, vals []*Value) {
+ fmt.Fprintf(p.w, "name %s: %v\n", n.Name(), vals)
+}
+
+func fprintFunc(p funcPrinter, f *Func) {
+ reachable, live := findlive(f)
+ p.header(f)
+ printed := make([]bool, f.NumValues())
+ for _, b := range f.Blocks {
+ p.startBlock(b, reachable[b.ID])
+
+ if f.scheduled {
+ // Order of Values has been decided - print in that order.
+ for _, v := range b.Values {
+ p.value(v, live[v.ID])
+ printed[v.ID] = true
+ }
+ p.endBlock(b)
+ continue
+ }
+
+ // print phis first since all value cycles contain a phi
+ n := 0
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ continue
+ }
+ p.value(v, live[v.ID])
+ printed[v.ID] = true
+ n++
+ }
+
+ // print rest of values in dependency order
+ for n < len(b.Values) {
+ m := n
+ outer:
+ for _, v := range b.Values {
+ if printed[v.ID] {
+ continue
+ }
+ for _, w := range v.Args {
+ // w == nil shouldn't happen, but if it does,
+ // don't panic; we'll get a better diagnosis later.
+ if w != nil && w.Block == b && !printed[w.ID] {
+ continue outer
+ }
+ }
+ p.value(v, live[v.ID])
+ printed[v.ID] = true
+ n++
+ }
+ if m == n {
+ p.startDepCycle()
+ for _, v := range b.Values {
+ if printed[v.ID] {
+ continue
+ }
+ p.value(v, live[v.ID])
+ printed[v.ID] = true
+ n++
+ }
+ p.endDepCycle()
+ }
+ }
+
+ p.endBlock(b)
+ }
+ for name, vals := range f.NamedValues {
+ p.named(name, vals)
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/prove.go b/src/cmd/compile/internal/ssa/prove.go
new file mode 100644
index 0000000..a915e0b
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/prove.go
@@ -0,0 +1,351 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// rangeMask represents the possible relations between a pair of variables.
+type rangeMask uint
+
+const (
+ lt rangeMask = 1 << iota
+ eq
+ gt
+)
+
+// typeMask represents the universe of a variable pair in which
+// a set of relations is known.
+// For example, information learned for unsigned pairs cannot
+// be transfered to signed pairs because the same bit representation
+// can mean something else.
+type typeMask uint
+
+const (
+ signed typeMask = 1 << iota
+ unsigned
+ pointer
+)
+
+type typeRange struct {
+ t typeMask
+ r rangeMask
+}
+
+type control struct {
+ tm typeMask
+ a0, a1 ID
+}
+
+var (
+ reverseBits = [...]rangeMask{0, 4, 2, 6, 1, 5, 3, 7}
+
+ // maps what we learn when the positive branch is taken.
+ // For example:
+ // OpLess8: {signed, lt},
+ // v1 = (OpLess8 v2 v3).
+ // If v1 branch is taken than we learn that the rangeMaks
+ // can be at most lt.
+ typeRangeTable = map[Op]typeRange{
+ OpEq8: {signed | unsigned, eq},
+ OpEq16: {signed | unsigned, eq},
+ OpEq32: {signed | unsigned, eq},
+ OpEq64: {signed | unsigned, eq},
+ OpEqPtr: {pointer, eq},
+
+ OpNeq8: {signed | unsigned, lt | gt},
+ OpNeq16: {signed | unsigned, lt | gt},
+ OpNeq32: {signed | unsigned, lt | gt},
+ OpNeq64: {signed | unsigned, lt | gt},
+ OpNeqPtr: {pointer, lt | gt},
+
+ OpLess8: {signed, lt},
+ OpLess8U: {unsigned, lt},
+ OpLess16: {signed, lt},
+ OpLess16U: {unsigned, lt},
+ OpLess32: {signed, lt},
+ OpLess32U: {unsigned, lt},
+ OpLess64: {signed, lt},
+ OpLess64U: {unsigned, lt},
+
+ OpLeq8: {signed, lt | eq},
+ OpLeq8U: {unsigned, lt | eq},
+ OpLeq16: {signed, lt | eq},
+ OpLeq16U: {unsigned, lt | eq},
+ OpLeq32: {signed, lt | eq},
+ OpLeq32U: {unsigned, lt | eq},
+ OpLeq64: {signed, lt | eq},
+ OpLeq64U: {unsigned, lt | eq},
+
+ OpGeq8: {signed, eq | gt},
+ OpGeq8U: {unsigned, eq | gt},
+ OpGeq16: {signed, eq | gt},
+ OpGeq16U: {unsigned, eq | gt},
+ OpGeq32: {signed, eq | gt},
+ OpGeq32U: {unsigned, eq | gt},
+ OpGeq64: {signed, eq | gt},
+ OpGeq64U: {unsigned, eq | gt},
+
+ OpGreater8: {signed, gt},
+ OpGreater8U: {unsigned, gt},
+ OpGreater16: {signed, gt},
+ OpGreater16U: {unsigned, gt},
+ OpGreater32: {signed, gt},
+ OpGreater32U: {unsigned, gt},
+ OpGreater64: {signed, gt},
+ OpGreater64U: {unsigned, gt},
+
+ // TODO: OpIsInBounds actually test 0 <= a < b. This means
+ // that the positive branch learns signed/LT and unsigned/LT
+ // but the negative branch only learns unsigned/GE.
+ OpIsInBounds: {unsigned, lt},
+ OpIsSliceInBounds: {unsigned, lt | eq},
+ }
+)
+
+// prove removes redundant BlockIf controls that can be inferred in a straight line.
+//
+// By far, the most common redundant control are generated by bounds checking.
+// For example for the code:
+//
+// a[i] = 4
+// foo(a[i])
+//
+// The compiler will generate the following code:
+//
+// if i >= len(a) {
+// panic("not in bounds")
+// }
+// a[i] = 4
+// if i >= len(a) {
+// panic("not in bounds")
+// }
+// foo(a[i])
+//
+// The second comparison i >= len(a) is clearly redundant because if the
+// else branch of the first comparison is executed, we already know that i < len(a).
+// The code for the second panic can be removed.
+func prove(f *Func) {
+ idom := dominators(f)
+ sdom := newSparseTree(f, idom)
+
+ // current node state
+ type walkState int
+ const (
+ descend walkState = iota
+ simplify
+ )
+ // work maintains the DFS stack.
+ type bp struct {
+ block *Block // current handled block
+ state walkState // what's to do
+ saved []typeRange // save previous map entries modified by node
+ }
+ work := make([]bp, 0, 256)
+ work = append(work, bp{
+ block: f.Entry,
+ state: descend,
+ })
+
+ // mask keep tracks of restrictions for each pair of values in
+ // the dominators for the current node.
+ // Invariant: a0.ID <= a1.ID
+ // For example {unsigned, a0, a1} -> eq|gt means that from
+ // predecessors we know that a0 must be greater or equal to
+ // a1.
+ mask := make(map[control]rangeMask)
+
+ // DFS on the dominator tree.
+ for len(work) > 0 {
+ node := work[len(work)-1]
+ work = work[:len(work)-1]
+
+ switch node.state {
+ case descend:
+ parent := idom[node.block.ID]
+ tr := getRestrict(sdom, parent, node.block)
+ saved := updateRestrictions(mask, parent, tr)
+
+ work = append(work, bp{
+ block: node.block,
+ state: simplify,
+ saved: saved,
+ })
+
+ for s := sdom.Child(node.block); s != nil; s = sdom.Sibling(s) {
+ work = append(work, bp{
+ block: s,
+ state: descend,
+ })
+ }
+
+ case simplify:
+ simplifyBlock(mask, node.block)
+ restoreRestrictions(mask, idom[node.block.ID], node.saved)
+ }
+ }
+}
+
+// getRestrict returns the range restrictions added by p
+// when reaching b. p is the immediate dominator or b.
+func getRestrict(sdom sparseTree, p *Block, b *Block) typeRange {
+ if p == nil || p.Kind != BlockIf {
+ return typeRange{}
+ }
+ tr, has := typeRangeTable[p.Control.Op]
+ if !has {
+ return typeRange{}
+ }
+ // If p and p.Succs[0] are dominators it means that every path
+ // from entry to b passes through p and p.Succs[0]. We care that
+ // no path from entry to b passes through p.Succs[1]. If p.Succs[0]
+ // has one predecessor then (apart from the degenerate case),
+ // there is no path from entry that can reach b through p.Succs[1].
+ // TODO: how about p->yes->b->yes, i.e. a loop in yes.
+ if sdom.isAncestorEq(p.Succs[0], b) && len(p.Succs[0].Preds) == 1 {
+ return tr
+ } else if sdom.isAncestorEq(p.Succs[1], b) && len(p.Succs[1].Preds) == 1 {
+ tr.r = (lt | eq | gt) ^ tr.r
+ return tr
+ }
+ return typeRange{}
+}
+
+// updateRestrictions updates restrictions from the previous block (p) based on tr.
+// normally tr was calculated with getRestrict.
+func updateRestrictions(mask map[control]rangeMask, p *Block, tr typeRange) []typeRange {
+ if tr.t == 0 {
+ return nil
+ }
+
+ // p modifies the restrictions for (a0, a1).
+ // save and return the previous state.
+ a0 := p.Control.Args[0]
+ a1 := p.Control.Args[1]
+ if a0.ID > a1.ID {
+ tr.r = reverseBits[tr.r]
+ a0, a1 = a1, a0
+ }
+
+ saved := make([]typeRange, 0, 2)
+ for t := typeMask(1); t <= tr.t; t <<= 1 {
+ if t&tr.t == 0 {
+ continue
+ }
+
+ i := control{t, a0.ID, a1.ID}
+ oldRange, ok := mask[i]
+ if !ok {
+ if a1 != a0 {
+ oldRange = lt | eq | gt
+ } else { // sometimes happens after cse
+ oldRange = eq
+ }
+ }
+ // if i was not already in the map we save the full range
+ // so that when we restore it we properly keep track of it.
+ saved = append(saved, typeRange{t, oldRange})
+ // mask[i] contains the possible relations between a0 and a1.
+ // When we branched from parent we learned that the possible
+ // relations cannot be more than tr.r. We compute the new set of
+ // relations as the intersection betwee the old and the new set.
+ mask[i] = oldRange & tr.r
+ }
+ return saved
+}
+
+func restoreRestrictions(mask map[control]rangeMask, p *Block, saved []typeRange) {
+ if p == nil || p.Kind != BlockIf || len(saved) == 0 {
+ return
+ }
+
+ a0 := p.Control.Args[0].ID
+ a1 := p.Control.Args[1].ID
+ if a0 > a1 {
+ a0, a1 = a1, a0
+ }
+
+ for _, tr := range saved {
+ i := control{tr.t, a0, a1}
+ if tr.r != lt|eq|gt {
+ mask[i] = tr.r
+ } else {
+ delete(mask, i)
+ }
+ }
+}
+
+// simplifyBlock simplifies block known the restrictions in mask.
+func simplifyBlock(mask map[control]rangeMask, b *Block) {
+ if b.Kind != BlockIf {
+ return
+ }
+
+ tr, has := typeRangeTable[b.Control.Op]
+ if !has {
+ return
+ }
+
+ succ := -1
+ a0 := b.Control.Args[0].ID
+ a1 := b.Control.Args[1].ID
+ if a0 > a1 {
+ tr.r = reverseBits[tr.r]
+ a0, a1 = a1, a0
+ }
+
+ for t := typeMask(1); t <= tr.t; t <<= 1 {
+ if t&tr.t == 0 {
+ continue
+ }
+
+ // tr.r represents in which case the positive branch is taken.
+ // m.r represents which cases are possible because of previous relations.
+ // If the set of possible relations m.r is included in the set of relations
+ // need to take the positive branch (or negative) then that branch will
+ // always be taken.
+ // For shortcut, if m.r == 0 then this block is dead code.
+ i := control{t, a0, a1}
+ m := mask[i]
+ if m != 0 && tr.r&m == m {
+ if b.Func.pass.debug > 0 {
+ b.Func.Config.Warnl(int(b.Line), "Proved %s", b.Control.Op)
+ }
+ b.Logf("proved positive branch of %s, block %s in %s\n", b.Control, b, b.Func.Name)
+ succ = 0
+ break
+ }
+ if m != 0 && ((lt|eq|gt)^tr.r)&m == m {
+ if b.Func.pass.debug > 0 {
+ b.Func.Config.Warnl(int(b.Line), "Disproved %s", b.Control.Op)
+ }
+ b.Logf("proved negative branch of %s, block %s in %s\n", b.Control, b, b.Func.Name)
+ succ = 1
+ break
+ }
+ }
+
+ if succ == -1 {
+ // HACK: If the first argument of IsInBounds or IsSliceInBounds
+ // is a constant and we already know that constant is smaller (or equal)
+ // to the upper bound than this is proven. Most useful in cases such as:
+ // if len(a) <= 1 { return }
+ // do something with a[1]
+ c := b.Control
+ if (c.Op == OpIsInBounds || c.Op == OpIsSliceInBounds) &&
+ c.Args[0].Op == OpConst64 && c.Args[0].AuxInt >= 0 {
+ m := mask[control{signed, a0, a1}]
+ if m != 0 && tr.r&m == m {
+ if b.Func.pass.debug > 0 {
+ b.Func.Config.Warnl(int(b.Line), "Proved constant %s", c.Op)
+ }
+ succ = 0
+ }
+ }
+ }
+
+ if succ != -1 {
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0], b.Succs[1] = b.Succs[succ], b.Succs[1-succ]
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
new file mode 100644
index 0000000..e900a3c
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -0,0 +1,1658 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Register allocation.
+//
+// We use a version of a linear scan register allocator. We treat the
+// whole function as a single long basic block and run through
+// it using a greedy register allocator. Then all merge edges
+// (those targeting a block with len(Preds)>1) are processed to
+// shuffle data into the place that the target of the edge expects.
+//
+// The greedy allocator moves values into registers just before they
+// are used, spills registers only when necessary, and spills the
+// value whose next use is farthest in the future.
+//
+// The register allocator requires that a block is not scheduled until
+// at least one of its predecessors have been scheduled. The most recent
+// such predecessor provides the starting register state for a block.
+//
+// It also requires that there are no critical edges (critical =
+// comes from a block with >1 successor and goes to a block with >1
+// predecessor). This makes it easy to add fixup code on merge edges -
+// the source of a merge edge has only one successor, so we can add
+// fixup code to the end of that block.
+
+// Spilling
+//
+// For every value, we generate a spill immediately after the value itself.
+// x = Op y z : AX
+// x2 = StoreReg x
+// While AX still holds x, any uses of x will use that value. When AX is needed
+// for another value, we simply reuse AX. Spill code has already been generated
+// so there is no code generated at "spill" time. When x is referenced
+// subsequently, we issue a load to restore x to a register using x2 as
+// its argument:
+// x3 = Restore x2 : CX
+// x3 can then be used wherever x is referenced again.
+// If the spill (x2) is never used, it will be removed at the end of regalloc.
+//
+// Phi values are special, as always. We define two kinds of phis, those
+// where the merge happens in a register (a "register" phi) and those where
+// the merge happens in a stack location (a "stack" phi).
+//
+// A register phi must have the phi and all of its inputs allocated to the
+// same register. Register phis are spilled similarly to regular ops:
+// b1: y = ... : AX b2: z = ... : AX
+// goto b3 goto b3
+// b3: x = phi(y, z) : AX
+// x2 = StoreReg x
+//
+// A stack phi must have the phi and all of its inputs allocated to the same
+// stack location. Stack phis start out life already spilled - each phi
+// input must be a store (using StoreReg) at the end of the corresponding
+// predecessor block.
+// b1: y = ... : AX b2: z = ... : BX
+// y2 = StoreReg y z2 = StoreReg z
+// goto b3 goto b3
+// b3: x = phi(y2, z2)
+// The stack allocator knows that StoreReg args of stack-allocated phis
+// must be allocated to the same stack slot as the phi that uses them.
+// x is now a spilled value and a restore must appear before its first use.
+
+// TODO
+
+// Use an affinity graph to mark two values which should use the
+// same register. This affinity graph will be used to prefer certain
+// registers for allocation. This affinity helps eliminate moves that
+// are required for phi implementations and helps generate allocations
+// for 2-register architectures.
+
+// Note: regalloc generates a not-quite-SSA output. If we have:
+//
+// b1: x = ... : AX
+// x2 = StoreReg x
+// ... AX gets reused for something else ...
+// if ... goto b3 else b4
+//
+// b3: x3 = LoadReg x2 : BX b4: x4 = LoadReg x2 : CX
+// ... use x3 ... ... use x4 ...
+//
+// b2: ... use x3 ...
+//
+// If b3 is the primary predecessor of b2, then we use x3 in b2 and
+// add a x4:CX->BX copy at the end of b4.
+// But the definition of x3 doesn't dominate b2. We should really
+// insert a dummy phi at the start of b2 (x5=phi(x3,x4):BX) to keep
+// SSA form. For now, we ignore this problem as remaining in strict
+// SSA form isn't needed after regalloc. We'll just leave the use
+// of x3 not dominated by the definition of x3, and the CX->BX copy
+// will have no use (so don't run deadcode after regalloc!).
+// TODO: maybe we should introduce these extra phis?
+
+package ssa
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "unsafe"
+)
+
+const regDebug = false // TODO: compiler flag
+const logSpills = false
+
+// regalloc performs register allocation on f. It sets f.RegAlloc
+// to the resulting allocation.
+func regalloc(f *Func) {
+ var s regAllocState
+ s.init(f)
+ s.regalloc(f)
+}
+
+type register uint8
+
+const noRegister register = 255
+
+type regMask uint64
+
+func (m regMask) String() string {
+ s := ""
+ for r := register(0); r < numRegs; r++ {
+ if m>>r&1 == 0 {
+ continue
+ }
+ if s != "" {
+ s += " "
+ }
+ s += fmt.Sprintf("r%d", r)
+ }
+ return s
+}
+
+// TODO: make arch-dependent
+var numRegs register = 64
+
+var registers = [...]Register{
+ Register{0, "AX"},
+ Register{1, "CX"},
+ Register{2, "DX"},
+ Register{3, "BX"},
+ Register{4, "SP"},
+ Register{5, "BP"},
+ Register{6, "SI"},
+ Register{7, "DI"},
+ Register{8, "R8"},
+ Register{9, "R9"},
+ Register{10, "R10"},
+ Register{11, "R11"},
+ Register{12, "R12"},
+ Register{13, "R13"},
+ Register{14, "R14"},
+ Register{15, "R15"},
+ Register{16, "X0"},
+ Register{17, "X1"},
+ Register{18, "X2"},
+ Register{19, "X3"},
+ Register{20, "X4"},
+ Register{21, "X5"},
+ Register{22, "X6"},
+ Register{23, "X7"},
+ Register{24, "X8"},
+ Register{25, "X9"},
+ Register{26, "X10"},
+ Register{27, "X11"},
+ Register{28, "X12"},
+ Register{29, "X13"},
+ Register{30, "X14"},
+ Register{31, "X15"},
+ Register{32, "SB"}, // pseudo-register for global base pointer (aka %rip)
+
+ // TODO: make arch-dependent
+}
+
+// countRegs returns the number of set bits in the register mask.
+func countRegs(r regMask) int {
+ n := 0
+ for r != 0 {
+ n += int(r & 1)
+ r >>= 1
+ }
+ return n
+}
+
+// pickReg picks an arbitrary register from the register mask.
+func pickReg(r regMask) register {
+ // pick the lowest one
+ if r == 0 {
+ panic("can't pick a register from an empty set")
+ }
+ for i := register(0); ; i++ {
+ if r&1 != 0 {
+ return i
+ }
+ r >>= 1
+ }
+}
+
+type use struct {
+ dist int32 // distance from start of the block to a use of a value
+ next *use // linked list of uses of a value in nondecreasing dist order
+}
+
+type valState struct {
+ regs regMask // the set of registers holding a Value (usually just one)
+ uses *use // list of uses in this block
+ spill *Value // spilled copy of the Value
+ spillUsed bool
+ needReg bool // cached value of !v.Type.IsMemory() && !v.Type.IsVoid() && !.v.Type.IsFlags()
+ rematerializeable bool // cached value of v.rematerializeable()
+ desired register // register we want value to be in, if any
+ avoid regMask // registers to avoid if we can
+}
+
+type regState struct {
+ v *Value // Original (preregalloc) Value stored in this register.
+ c *Value // A Value equal to v which is currently in a register. Might be v or a copy of it.
+ // If a register is unused, v==c==nil
+}
+
+type regAllocState struct {
+ f *Func
+
+ // for each block, its primary predecessor.
+ // A predecessor of b is primary if it is the closest
+ // predecessor that appears before b in the layout order.
+ // We record the index in the Preds list where the primary predecessor sits.
+ primary []int32
+
+ // live values at the end of each block. live[b.ID] is a list of value IDs
+ // which are live at the end of b, together with a count of how many instructions
+ // forward to the next use.
+ live [][]liveInfo
+
+ // current state of each (preregalloc) Value
+ values []valState
+
+ // For each Value, map from its value ID back to the
+ // preregalloc Value it was derived from.
+ orig []*Value
+
+ // current state of each register
+ regs []regState
+
+ // registers that contain values which can't be kicked out
+ nospill regMask
+
+ // mask of registers currently in use
+ used regMask
+
+ // current block we're working on
+ curBlock *Block
+
+ // cache of use records
+ freeUseRecords *use
+
+ // endRegs[blockid] is the register state at the end of each block.
+ // encoded as a set of endReg records.
+ endRegs [][]endReg
+
+ // startRegs[blockid] is the register state at the start of merge blocks.
+ // saved state does not include the state of phi ops in the block.
+ startRegs [][]startReg
+
+ // spillLive[blockid] is the set of live spills at the end of each block
+ spillLive [][]ID
+}
+
+type endReg struct {
+ r register
+ v *Value // pre-regalloc value held in this register (TODO: can we use ID here?)
+ c *Value // cached version of the value
+}
+
+type startReg struct {
+ r register
+ vid ID // pre-regalloc value needed in this register
+}
+
+// freeReg frees up register r. Any current user of r is kicked out.
+func (s *regAllocState) freeReg(r register) {
+ v := s.regs[r].v
+ if v == nil {
+ s.f.Fatalf("tried to free an already free register %d\n", r)
+ }
+
+ // Mark r as unused.
+ if regDebug {
+ fmt.Printf("freeReg %s (dump %s/%s)\n", registers[r].Name(), v, s.regs[r].c)
+ }
+ s.regs[r] = regState{}
+ s.values[v.ID].regs &^= regMask(1) << r
+ s.used &^= regMask(1) << r
+}
+
+// freeRegs frees up all registers listed in m.
+func (s *regAllocState) freeRegs(m regMask) {
+ for m&s.used != 0 {
+ s.freeReg(pickReg(m & s.used))
+ }
+}
+
+// setOrig records that c's original value is the same as
+// v's original value.
+func (s *regAllocState) setOrig(c *Value, v *Value) {
+ for int(c.ID) >= len(s.orig) {
+ s.orig = append(s.orig, nil)
+ }
+ if s.orig[c.ID] != nil {
+ s.f.Fatalf("orig value set twice %s %s", c, v)
+ }
+ s.orig[c.ID] = s.orig[v.ID]
+}
+
+// assignReg assigns register r to hold c, a copy of v.
+// r must be unused.
+func (s *regAllocState) assignReg(r register, v *Value, c *Value) {
+ if regDebug {
+ fmt.Printf("assignReg %s %s/%s\n", registers[r].Name(), v, c)
+ }
+ if s.regs[r].v != nil {
+ s.f.Fatalf("tried to assign register %d to %s/%s but it is already used by %s", r, v, c, s.regs[r].v)
+ }
+
+ // Update state.
+ s.regs[r] = regState{v, c}
+ s.values[v.ID].regs |= regMask(1) << r
+ s.used |= regMask(1) << r
+ s.f.setHome(c, ®isters[r])
+}
+
+// allocReg chooses a register for v from the set of registers in mask.
+// If there is no unused register, a Value will be kicked out of
+// a register to make room.
+func (s *regAllocState) allocReg(v *Value, mask regMask) register {
+ mask &^= s.nospill
+ if mask == 0 {
+ s.f.Fatalf("no register available")
+ }
+
+ // Pick an unused register if one is available.
+ if mask&^s.used != 0 {
+ mask &^= s.used
+
+ // Use desired register if we can.
+ d := s.values[v.ID].desired
+ if d != noRegister && mask>>d&1 != 0 {
+ mask = regMask(1) << d
+ }
+
+ // Avoid avoidable registers if we can.
+ if mask&^s.values[v.ID].avoid != 0 {
+ mask &^= s.values[v.ID].avoid
+ }
+
+ return pickReg(mask)
+ }
+
+ // Pick a value to spill. Spill the value with the
+ // farthest-in-the-future use.
+ // TODO: Prefer registers with already spilled Values?
+ // TODO: Modify preference using affinity graph.
+ // TODO: if a single value is in multiple registers, spill one of them
+ // before spilling a value in just a single register.
+
+ // SP and SB are allocated specially. No regular value should
+ // be allocated to them.
+ mask &^= 1<<4 | 1<<32
+
+ // Find a register to spill. We spill the register containing the value
+ // whose next use is as far in the future as possible.
+ // https://en.wikipedia.org/wiki/Page_replacement_algorithm#The_theoretically_optimal_page_replacement_algorithm
+ var r register
+ maxuse := int32(-1)
+ for t := register(0); t < numRegs; t++ {
+ if mask>>t&1 == 0 {
+ continue
+ }
+ v := s.regs[t].v
+ if n := s.values[v.ID].uses.dist; n > maxuse {
+ // v's next use is farther in the future than any value
+ // we've seen so far. A new best spill candidate.
+ r = t
+ maxuse = n
+ }
+ }
+ if maxuse == -1 {
+ s.f.Unimplementedf("couldn't find register to spill")
+ }
+ s.freeReg(r)
+ return r
+}
+
+// allocValToReg allocates v to a register selected from regMask and
+// returns the register copy of v. Any previous user is kicked out and spilled
+// (if necessary). Load code is added at the current pc. If nospill is set the
+// allocated register is marked nospill so the assignment cannot be
+// undone until the caller allows it by clearing nospill. Returns a
+// *Value which is either v or a copy of v allocated to the chosen register.
+func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool, line int32) *Value {
+ vi := &s.values[v.ID]
+
+ // Check if v is already in a requested register.
+ if mask&vi.regs != 0 {
+ r := pickReg(mask & vi.regs)
+ if s.regs[r].v != v || s.regs[r].c == nil {
+ panic("bad register state")
+ }
+ if nospill {
+ s.nospill |= regMask(1) << r
+ }
+ return s.regs[r].c
+ }
+
+ if v.Op != OpSP {
+ mask &^= 1 << 4 // dont' spill SP
+ }
+ if v.Op != OpSB {
+ mask &^= 1 << 32 // don't spill SB
+ }
+ mask &^= s.reserved()
+
+ // Allocate a register.
+ r := s.allocReg(v, mask)
+
+ // Allocate v to the new register.
+ var c *Value
+ if vi.regs != 0 {
+ // Copy from a register that v is already in.
+ r2 := pickReg(vi.regs)
+ if s.regs[r2].v != v {
+ panic("bad register state")
+ }
+ c = s.curBlock.NewValue1(line, OpCopy, v.Type, s.regs[r2].c)
+ } else if v.rematerializeable() {
+ // Rematerialize instead of loading from the spill location.
+ c = v.copyInto(s.curBlock)
+ } else {
+ switch {
+ // Load v from its spill location.
+ case vi.spill != nil:
+ if logSpills {
+ fmt.Println("regalloc: load spill")
+ }
+ c = s.curBlock.NewValue1(line, OpLoadReg, v.Type, vi.spill)
+ vi.spillUsed = true
+ default:
+ s.f.Fatalf("attempt to load unspilled value %v", v.LongString())
+ }
+ }
+ s.setOrig(c, v)
+ s.assignReg(r, v, c)
+ if nospill {
+ s.nospill |= regMask(1) << r
+ }
+ return c
+}
+
+func (s *regAllocState) init(f *Func) {
+ if numRegs > noRegister || numRegs > register(unsafe.Sizeof(regMask(0))*8) {
+ panic("too many registers")
+ }
+
+ s.f = f
+ s.regs = make([]regState, numRegs)
+ s.values = make([]valState, f.NumValues())
+ s.orig = make([]*Value, f.NumValues())
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags() {
+ s.values[v.ID].needReg = true
+ s.values[v.ID].rematerializeable = v.rematerializeable()
+ s.values[v.ID].desired = noRegister
+ s.orig[v.ID] = v
+ }
+ }
+ }
+ s.computeLive()
+
+ // Compute block order. This array allows us to distinguish forward edges
+ // from backward edges and compute how far they go.
+ blockOrder := make([]int32, f.NumBlocks())
+ for i, b := range f.Blocks {
+ blockOrder[b.ID] = int32(i)
+ }
+
+ // Compute primary predecessors.
+ s.primary = make([]int32, f.NumBlocks())
+ for _, b := range f.Blocks {
+ best := -1
+ for i, p := range b.Preds {
+ if blockOrder[p.ID] >= blockOrder[b.ID] {
+ continue // backward edge
+ }
+ if best == -1 || blockOrder[p.ID] > blockOrder[b.Preds[best].ID] {
+ best = i
+ }
+ }
+ s.primary[b.ID] = int32(best)
+ }
+
+ s.endRegs = make([][]endReg, f.NumBlocks())
+ s.startRegs = make([][]startReg, f.NumBlocks())
+ s.spillLive = make([][]ID, f.NumBlocks())
+}
+
+// Adds a use record for id at distance dist from the start of the block.
+// All calls to addUse must happen with nonincreasing dist.
+func (s *regAllocState) addUse(id ID, dist int32) {
+ r := s.freeUseRecords
+ if r != nil {
+ s.freeUseRecords = r.next
+ } else {
+ r = &use{}
+ }
+ r.dist = dist
+ r.next = s.values[id].uses
+ s.values[id].uses = r
+ if r.next != nil && dist > r.next.dist {
+ s.f.Fatalf("uses added in wrong order")
+ }
+}
+
+// advanceUses advances the uses of v's args from the state before v to the state after v.
+// Any values which have no more uses are deallocated from registers.
+func (s *regAllocState) advanceUses(v *Value) {
+ for _, a := range v.Args {
+ if !s.values[a.ID].needReg {
+ continue
+ }
+ ai := &s.values[a.ID]
+ r := ai.uses
+ ai.uses = r.next
+ if r.next == nil {
+ // Value is dead, free all registers that hold it.
+ s.freeRegs(ai.regs)
+ }
+ r.next = s.freeUseRecords
+ s.freeUseRecords = r
+ }
+}
+
+// Sets the state of the registers to that encoded in regs.
+func (s *regAllocState) setState(regs []endReg) {
+ s.freeRegs(s.used)
+ for _, x := range regs {
+ s.assignReg(x.r, x.v, x.c)
+ }
+}
+
+// compatRegs returns the set of registers which can store a type t.
+func (s *regAllocState) compatRegs(t Type) regMask {
+ var m regMask
+ if t.IsFloat() {
+ m = 0xffff << 16 // X0-X15
+ } else {
+ m = 0xffef << 0 // AX-R15, except SP
+ }
+ return m &^ s.reserved()
+}
+
+func (s *regAllocState) regalloc(f *Func) {
+ liveSet := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(liveSet)
+ var oldSched []*Value
+ var phis []*Value
+ var phiRegs []register
+ var args []*Value
+
+ if f.Entry != f.Blocks[0] {
+ f.Fatalf("entry block must be first")
+ }
+
+ for _, b := range f.Blocks {
+ s.curBlock = b
+
+ // Initialize liveSet and uses fields for this block.
+ // Walk backwards through the block doing liveness analysis.
+ liveSet.clear()
+ for _, e := range s.live[b.ID] {
+ s.addUse(e.ID, int32(len(b.Values))+e.dist) // pseudo-uses from beyond end of block
+ liveSet.add(e.ID)
+ }
+ if v := b.Control; v != nil && s.values[v.ID].needReg {
+ s.addUse(v.ID, int32(len(b.Values))) // psuedo-use by control value
+ liveSet.add(v.ID)
+ }
+ for i := len(b.Values) - 1; i >= 0; i-- {
+ v := b.Values[i]
+ liveSet.remove(v.ID)
+ if v.Op == OpPhi {
+ // Remove v from the live set, but don't add
+ // any inputs. This is the state the len(b.Preds)>1
+ // case below desires; it wants to process phis specially.
+ continue
+ }
+ for _, a := range v.Args {
+ if !s.values[a.ID].needReg {
+ continue
+ }
+ s.addUse(a.ID, int32(i))
+ liveSet.add(a.ID)
+ }
+ }
+ if regDebug {
+ fmt.Printf("uses for %s:%s\n", s.f.Name, b)
+ for i := range s.values {
+ vi := &s.values[i]
+ u := vi.uses
+ if u == nil {
+ continue
+ }
+ fmt.Printf(" v%d:", i)
+ for u != nil {
+ fmt.Printf(" %d", u.dist)
+ u = u.next
+ }
+ fmt.Println()
+ }
+ }
+
+ // Make a copy of the block schedule so we can generate a new one in place.
+ // We make a separate copy for phis and regular values.
+ nphi := 0
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ break
+ }
+ nphi++
+ }
+ phis = append(phis[:0], b.Values[:nphi]...)
+ oldSched = append(oldSched[:0], b.Values[nphi:]...)
+ b.Values = b.Values[:0]
+
+ // Initialize start state of block.
+ if b == f.Entry {
+ // Regalloc state is empty to start.
+ if nphi > 0 {
+ f.Fatalf("phis in entry block")
+ }
+ } else if len(b.Preds) == 1 {
+ // Start regalloc state with the end state of the previous block.
+ s.setState(s.endRegs[b.Preds[0].ID])
+ if nphi > 0 {
+ f.Fatalf("phis in single-predecessor block")
+ }
+ // Drop any values which are no longer live.
+ // This may happen because at the end of p, a value may be
+ // live but only used by some other successor of p.
+ for r := register(0); r < numRegs; r++ {
+ v := s.regs[r].v
+ if v != nil && !liveSet.contains(v.ID) {
+ s.freeReg(r)
+ }
+ }
+ } else {
+ // This is the complicated case. We have more than one predecessor,
+ // which means we may have Phi ops.
+
+ // Copy phi ops into new schedule.
+ b.Values = append(b.Values, phis...)
+
+ // Start with the final register state of the primary predecessor
+ idx := s.primary[b.ID]
+ if idx < 0 {
+ f.Fatalf("block with no primary predecessor %s", b)
+ }
+ p := b.Preds[idx]
+ s.setState(s.endRegs[p.ID])
+
+ if regDebug {
+ fmt.Printf("starting merge block %s with end state of %s:\n", b, p)
+ for _, x := range s.endRegs[p.ID] {
+ fmt.Printf(" %s: orig:%s cache:%s\n", registers[x.r].Name(), x.v, x.c)
+ }
+ }
+
+ // Decide on registers for phi ops. Use the registers determined
+ // by the primary predecessor if we can.
+ // TODO: pick best of (already processed) predecessors?
+ // Majority vote? Deepest nesting level?
+ phiRegs = phiRegs[:0]
+ var phiUsed regMask
+ for _, v := range phis {
+ if !s.values[v.ID].needReg {
+ phiRegs = append(phiRegs, noRegister)
+ continue
+ }
+ a := v.Args[idx]
+ m := s.values[a.ID].regs &^ phiUsed
+ var r register
+ if m != 0 {
+ r = pickReg(m)
+ s.freeReg(r)
+ phiUsed |= regMask(1) << r
+ phiRegs = append(phiRegs, r)
+ } else {
+ phiRegs = append(phiRegs, noRegister)
+ }
+ }
+
+ // Second pass - deallocate any phi inputs which are now dead.
+ for _, v := range phis {
+ if !s.values[v.ID].needReg {
+ continue
+ }
+ a := v.Args[idx]
+ if !liveSet.contains(a.ID) {
+ // Input is dead beyond the phi, deallocate
+ // anywhere else it might live.
+ s.freeRegs(s.values[a.ID].regs)
+ }
+ }
+
+ // Third pass - pick registers for phis whose inputs
+ // were not in a register.
+ for i, v := range phis {
+ if !s.values[v.ID].needReg {
+ continue
+ }
+ if phiRegs[i] != noRegister {
+ continue
+ }
+ m := s.compatRegs(v.Type) &^ phiUsed &^ s.used
+ if m != 0 {
+ r := pickReg(m)
+ phiRegs[i] = r
+ phiUsed |= regMask(1) << r
+ }
+ }
+
+ // Set registers for phis. Add phi spill code.
+ for i, v := range phis {
+ if !s.values[v.ID].needReg {
+ continue
+ }
+ r := phiRegs[i]
+ if r == noRegister {
+ // stack-based phi
+ // Spills will be inserted in all the predecessors below.
+ s.values[v.ID].spill = v // v starts life spilled
+ s.values[v.ID].spillUsed = true // use is guaranteed
+ continue
+ }
+ // register-based phi
+ s.assignReg(r, v, v)
+ // Spill the phi in case we need to restore it later.
+ spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v)
+ s.setOrig(spill, v)
+ s.values[v.ID].spill = spill
+ s.values[v.ID].spillUsed = false
+ }
+
+ // Save the starting state for use by merge edges.
+ var regList []startReg
+ for r := register(0); r < numRegs; r++ {
+ v := s.regs[r].v
+ if v == nil {
+ continue
+ }
+ if phiUsed>>r&1 != 0 {
+ // Skip registers that phis used, we'll handle those
+ // specially during merge edge processing.
+ continue
+ }
+ regList = append(regList, startReg{r, v.ID})
+ }
+ s.startRegs[b.ID] = regList
+
+ if regDebug {
+ fmt.Printf("after phis\n")
+ for _, x := range s.startRegs[b.ID] {
+ fmt.Printf(" %s: v%d\n", registers[x.r].Name(), x.vid)
+ }
+ }
+ }
+
+ // Compute preferred registers for each value using a backwards pass.
+ // Note that we do this phase after startRegs is set above, so that
+ // we get the right behavior for a block which branches to itself.
+ for _, succ := range b.Succs {
+ // TODO: prioritize likely successor.
+ for _, x := range s.startRegs[succ.ID] {
+ v := s.orig[x.vid]
+ s.values[v.ID].desired = x.r
+ }
+ // Process phi ops in succ
+ i := -1
+ for j, p := range succ.Preds {
+ if p == b {
+ i = j
+ break
+ }
+ }
+ if i == -1 {
+ s.f.Fatalf("can't find predecssor %s of %s\n", b, succ)
+ }
+ for _, v := range succ.Values {
+ if v.Op != OpPhi {
+ break
+ }
+ if !s.values[v.ID].needReg {
+ continue
+ }
+ r, ok := s.f.getHome(v.ID).(*Register)
+ if !ok {
+ continue
+ }
+ a := s.orig[v.Args[i].ID]
+ s.values[a.ID].desired = register(r.Num)
+ }
+ }
+
+ // Set avoid fields to help desired register availability.
+ liveSet.clear()
+ for _, e := range s.live[b.ID] {
+ liveSet.add(e.ID)
+ }
+ if v := b.Control; v != nil && s.values[v.ID].needReg {
+ liveSet.add(v.ID)
+ }
+ for i := len(oldSched) - 1; i >= 0; i-- {
+ v := oldSched[i]
+ liveSet.remove(v.ID)
+
+ r := s.values[v.ID].desired
+ if r != noRegister {
+ m := regMask(1) << r
+ // All live values should avoid this register so
+ // it will be available at this point.
+ for _, w := range liveSet.contents() {
+ s.values[w].avoid |= m
+ }
+ }
+
+ for _, a := range v.Args {
+ if !s.values[a.ID].needReg {
+ continue
+ }
+ liveSet.add(a.ID)
+ }
+ }
+
+ // Process all the non-phi values.
+ for _, v := range oldSched {
+ if regDebug {
+ fmt.Printf(" processing %s\n", v.LongString())
+ }
+ if v.Op == OpPhi {
+ f.Fatalf("phi %s not at start of block", v)
+ }
+ if v.Op == OpSP {
+ s.assignReg(4, v, v) // TODO: arch-dependent
+ b.Values = append(b.Values, v)
+ s.advanceUses(v)
+ continue
+ }
+ if v.Op == OpSB {
+ s.assignReg(32, v, v) // TODO: arch-dependent
+ b.Values = append(b.Values, v)
+ s.advanceUses(v)
+ continue
+ }
+ if v.Op == OpArg {
+ // Args are "pre-spilled" values. We don't allocate
+ // any register here. We just set up the spill pointer to
+ // point at itself and any later user will restore it to use it.
+ s.values[v.ID].spill = v
+ s.values[v.ID].spillUsed = true // use is guaranteed
+ b.Values = append(b.Values, v)
+ s.advanceUses(v)
+ continue
+ }
+ regspec := opcodeTable[v.Op].reg
+ if len(regspec.inputs) == 0 && len(regspec.outputs) == 0 {
+ // No register allocation required (or none specified yet)
+ s.freeRegs(regspec.clobbers)
+ b.Values = append(b.Values, v)
+ continue
+ }
+
+ if s.values[v.ID].rematerializeable {
+ // Value is rematerializeable, don't issue it here.
+ // It will get issued just before each use (see
+ // allocValueToReg).
+ s.advanceUses(v)
+ continue
+ }
+
+ // Move arguments to registers. Process in an ordering defined
+ // by the register specification (most constrained first).
+ args = append(args[:0], v.Args...)
+ for _, i := range regspec.inputs {
+ if i.regs == flagRegMask {
+ // TODO: remove flag input from regspec.inputs.
+ continue
+ }
+ args[i.idx] = s.allocValToReg(v.Args[i.idx], i.regs, true, v.Line)
+ }
+
+ // Now that all args are in regs, we're ready to issue the value itself.
+ // Before we pick a register for the output value, allow input registers
+ // to be deallocated. We do this here so that the output can use the
+ // same register as a dying input.
+ s.nospill = 0
+ s.advanceUses(v) // frees any registers holding args that are no longer live
+
+ // Dump any registers which will be clobbered
+ s.freeRegs(regspec.clobbers)
+
+ // Pick register for output.
+ var mask regMask
+ if s.values[v.ID].needReg {
+ mask = regspec.outputs[0] &^ s.reserved()
+ if mask>>33&1 != 0 {
+ s.f.Fatalf("bad mask %s\n", v.LongString())
+ }
+ }
+ if mask != 0 {
+ r := s.allocReg(v, mask)
+ s.assignReg(r, v, v)
+ }
+
+ // Issue the Value itself.
+ for i, a := range args {
+ v.Args[i] = a // use register version of arguments
+ }
+ b.Values = append(b.Values, v)
+
+ // Issue a spill for this value. We issue spills unconditionally,
+ // then at the end of regalloc delete the ones we never use.
+ // TODO: schedule the spill at a point that dominates all restores.
+ // The restore may be off in an unlikely branch somewhere and it
+ // would be better to have the spill in that unlikely branch as well.
+ // v := ...
+ // if unlikely {
+ // f()
+ // }
+ // It would be good to have both spill and restore inside the IF.
+ if s.values[v.ID].needReg {
+ spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v)
+ s.setOrig(spill, v)
+ s.values[v.ID].spill = spill
+ s.values[v.ID].spillUsed = false
+ }
+ }
+
+ if v := b.Control; v != nil && s.values[v.ID].needReg {
+ if regDebug {
+ fmt.Printf(" processing control %s\n", v.LongString())
+ }
+ // Load control value into reg.
+ // TODO: regspec for block control values, instead of using
+ // register set from the control op's output.
+ s.allocValToReg(v, opcodeTable[v.Op].reg.outputs[0], false, b.Line)
+ // Remove this use from the uses list.
+ vi := &s.values[v.ID]
+ u := vi.uses
+ vi.uses = u.next
+ if u.next == nil {
+ s.freeRegs(vi.regs) // value is dead
+ }
+ u.next = s.freeUseRecords
+ s.freeUseRecords = u
+ }
+
+ // Save end-of-block register state.
+ // First count how many, this cuts allocations in half.
+ k := 0
+ for r := register(0); r < numRegs; r++ {
+ v := s.regs[r].v
+ if v == nil {
+ continue
+ }
+ k++
+ }
+ regList := make([]endReg, 0, k)
+ for r := register(0); r < numRegs; r++ {
+ v := s.regs[r].v
+ if v == nil {
+ continue
+ }
+ regList = append(regList, endReg{r, v, s.regs[r].c})
+ }
+ s.endRegs[b.ID] = regList
+
+ // Check. TODO: remove
+ {
+ liveSet.clear()
+ for _, x := range s.live[b.ID] {
+ liveSet.add(x.ID)
+ }
+ for r := register(0); r < numRegs; r++ {
+ v := s.regs[r].v
+ if v == nil {
+ continue
+ }
+ if !liveSet.contains(v.ID) {
+ s.f.Fatalf("val %s is in reg but not live at end of %s", v, b)
+ }
+ }
+ }
+
+ // If a value is live at the end of the block and
+ // isn't in a register, remember that its spill location
+ // is live. We need to remember this information so that
+ // the liveness analysis in stackalloc is correct.
+ for _, e := range s.live[b.ID] {
+ if s.values[e.ID].regs != 0 {
+ // in a register, we'll use that source for the merge.
+ continue
+ }
+ spill := s.values[e.ID].spill
+ if spill == nil {
+ // rematerializeable values will have spill==nil.
+ continue
+ }
+ s.spillLive[b.ID] = append(s.spillLive[b.ID], spill.ID)
+ s.values[e.ID].spillUsed = true
+ }
+
+ // Clear any final uses.
+ // All that is left should be the pseudo-uses added for values which
+ // are live at the end of b.
+ for _, e := range s.live[b.ID] {
+ u := s.values[e.ID].uses
+ if u == nil {
+ f.Fatalf("live at end, no uses v%d", e.ID)
+ }
+ if u.next != nil {
+ f.Fatalf("live at end, too many uses v%d", e.ID)
+ }
+ s.values[e.ID].uses = nil
+ u.next = s.freeUseRecords
+ s.freeUseRecords = u
+ }
+ }
+
+ // Erase any spills we never used
+ for i := range s.values {
+ vi := s.values[i]
+ if vi.spillUsed {
+ if logSpills {
+ fmt.Println("regalloc: spilled value")
+ }
+ continue
+ }
+ spill := vi.spill
+ if spill == nil {
+ // Constants, SP, SB, ...
+ continue
+ }
+ f.freeValue(spill)
+ }
+ for _, b := range f.Blocks {
+ i := 0
+ for _, v := range b.Values {
+ if v.Op == OpInvalid {
+ continue
+ }
+ b.Values[i] = v
+ i++
+ }
+ b.Values = b.Values[:i]
+ // TODO: zero b.Values[i:], recycle Values
+ // Not important now because this is the last phase that manipulates Values
+ }
+
+ // Anything that didn't get a register gets a stack location here.
+ // (StoreReg, stack-based phis, inputs, ...)
+ stacklive := stackalloc(s.f, s.spillLive)
+
+ // Fix up all merge edges.
+ s.shuffle(stacklive)
+}
+
+// shuffle fixes up all the merge edges (those going into blocks of indegree > 1).
+func (s *regAllocState) shuffle(stacklive [][]ID) {
+ var e edgeState
+ e.s = s
+ e.cache = map[ID][]*Value{}
+ e.contents = map[Location]contentRecord{}
+ if regDebug {
+ fmt.Printf("shuffle %s\n", s.f.Name)
+ fmt.Println(s.f.String())
+ }
+
+ for _, b := range s.f.Blocks {
+ if len(b.Preds) <= 1 {
+ continue
+ }
+ e.b = b
+ for i, p := range b.Preds {
+ e.p = p
+ e.setup(i, s.endRegs[p.ID], s.startRegs[b.ID], stacklive[p.ID])
+ e.process()
+ }
+ }
+}
+
+type edgeState struct {
+ s *regAllocState
+ p, b *Block // edge goes from p->b.
+
+ // for each pre-regalloc value, a list of equivalent cached values
+ cache map[ID][]*Value
+
+ // map from location to the value it contains
+ contents map[Location]contentRecord
+
+ // desired destination locations
+ destinations []dstRecord
+ extra []dstRecord
+
+ usedRegs regMask // registers currently holding something
+ uniqueRegs regMask // registers holding the only copy of a value
+ finalRegs regMask // registers holding final target
+}
+
+type contentRecord struct {
+ vid ID // pre-regalloc value
+ c *Value // cached value
+ final bool // this is a satisfied destination
+}
+
+type dstRecord struct {
+ loc Location // register or stack slot
+ vid ID // pre-regalloc value it should contain
+ splice **Value // place to store reference to the generating instruction
+}
+
+// setup initializes the edge state for shuffling.
+func (e *edgeState) setup(idx int, srcReg []endReg, dstReg []startReg, stacklive []ID) {
+ if regDebug {
+ fmt.Printf("edge %s->%s\n", e.p, e.b)
+ }
+
+ // Clear state.
+ for k := range e.cache {
+ delete(e.cache, k)
+ }
+ for k := range e.contents {
+ delete(e.contents, k)
+ }
+ e.usedRegs = 0
+ e.uniqueRegs = 0
+ e.finalRegs = 0
+
+ // Live registers can be sources.
+ for _, x := range srcReg {
+ e.set(®isters[x.r], x.v.ID, x.c, false)
+ }
+ // So can all of the spill locations.
+ for _, spillID := range stacklive {
+ v := e.s.orig[spillID]
+ spill := e.s.values[v.ID].spill
+ e.set(e.s.f.getHome(spillID), v.ID, spill, false)
+ }
+
+ // Figure out all the destinations we need.
+ dsts := e.destinations[:0]
+ for _, x := range dstReg {
+ dsts = append(dsts, dstRecord{®isters[x.r], x.vid, nil})
+ }
+ // Phis need their args to end up in a specific location.
+ for _, v := range e.b.Values {
+ if v.Op != OpPhi {
+ break
+ }
+ loc := e.s.f.getHome(v.ID)
+ if loc == nil {
+ continue
+ }
+ dsts = append(dsts, dstRecord{loc, v.Args[idx].ID, &v.Args[idx]})
+ }
+ e.destinations = dsts
+
+ if regDebug {
+ for vid, a := range e.cache {
+ for _, c := range a {
+ fmt.Printf("src %s: v%d cache=%s\n", e.s.f.getHome(c.ID).Name(), vid, c)
+ }
+ }
+ for _, d := range e.destinations {
+ fmt.Printf("dst %s: v%d\n", d.loc.Name(), d.vid)
+ }
+ }
+}
+
+// process generates code to move all the values to the right destination locations.
+func (e *edgeState) process() {
+ dsts := e.destinations
+
+ // Process the destinations until they are all satisfied.
+ for len(dsts) > 0 {
+ i := 0
+ for _, d := range dsts {
+ if !e.processDest(d.loc, d.vid, d.splice) {
+ // Failed - save for next iteration.
+ dsts[i] = d
+ i++
+ }
+ }
+ if i < len(dsts) {
+ // Made some progress. Go around again.
+ dsts = dsts[:i]
+
+ // Append any extras destinations we generated.
+ dsts = append(dsts, e.extra...)
+ e.extra = e.extra[:0]
+ continue
+ }
+
+ // We made no progress. That means that any
+ // remaining unsatisfied moves are in simple cycles.
+ // For example, A -> B -> C -> D -> A.
+ // A ----> B
+ // ^ |
+ // | |
+ // | v
+ // D <---- C
+
+ // To break the cycle, we pick an unused register, say R,
+ // and put a copy of B there.
+ // A ----> B
+ // ^ |
+ // | |
+ // | v
+ // D <---- C <---- R=copyofB
+ // When we resume the outer loop, the A->B move can now proceed,
+ // and eventually the whole cycle completes.
+
+ // Copy any cycle location to a temp register. This duplicates
+ // one of the cycle entries, allowing the just duplicated value
+ // to be overwritten and the cycle to proceed.
+ loc := dsts[0].loc
+ vid := e.contents[loc].vid
+ c := e.contents[loc].c
+ r := e.findRegFor(c.Type)
+ if regDebug {
+ fmt.Printf("breaking cycle with v%d in %s:%s\n", vid, loc.Name(), c)
+ }
+ if _, isReg := loc.(*Register); isReg {
+ c = e.p.NewValue1(c.Line, OpCopy, c.Type, c)
+ } else {
+ c = e.p.NewValue1(c.Line, OpLoadReg, c.Type, c)
+ }
+ e.set(r, vid, c, false)
+ }
+}
+
+// processDest generates code to put value vid into location loc. Returns true
+// if progress was made.
+func (e *edgeState) processDest(loc Location, vid ID, splice **Value) bool {
+ occupant := e.contents[loc]
+ if occupant.vid == vid {
+ // Value is already in the correct place.
+ e.contents[loc] = contentRecord{vid, occupant.c, true}
+ if splice != nil {
+ *splice = occupant.c
+ }
+ // Note: if splice==nil then c will appear dead. This is
+ // non-SSA formed code, so be careful after this pass not to run
+ // deadcode elimination.
+ return true
+ }
+
+ // Check if we're allowed to clobber the destination location.
+ if len(e.cache[occupant.vid]) == 1 && !e.s.values[occupant.vid].rematerializeable {
+ // We can't overwrite the last copy
+ // of a value that needs to survive.
+ return false
+ }
+
+ // Copy from a source of v, register preferred.
+ v := e.s.orig[vid]
+ var c *Value
+ var src Location
+ if regDebug {
+ fmt.Printf("moving v%d to %s\n", vid, loc.Name())
+ fmt.Printf("sources of v%d:", vid)
+ }
+ for _, w := range e.cache[vid] {
+ h := e.s.f.getHome(w.ID)
+ if regDebug {
+ fmt.Printf(" %s:%s", h.Name(), w)
+ }
+ _, isreg := h.(*Register)
+ if src == nil || isreg {
+ c = w
+ src = h
+ }
+ }
+ if regDebug {
+ if src != nil {
+ fmt.Printf(" [use %s]\n", src.Name())
+ } else {
+ fmt.Printf(" [no source]\n")
+ }
+ }
+ _, dstReg := loc.(*Register)
+ var x *Value
+ if c == nil {
+ if !e.s.values[vid].rematerializeable {
+ e.s.f.Fatalf("can't find source for %s->%s: v%d\n", e.p, e.b, vid)
+ }
+ if dstReg {
+ x = v.copyInto(e.p)
+ } else {
+ // Rematerialize into stack slot. Need a free
+ // register to accomplish this.
+ e.erase(loc) // see pre-clobber comment below
+ r := e.findRegFor(v.Type)
+ x = v.copyInto(e.p)
+ e.set(r, vid, x, false)
+ // Make sure we spill with the size of the slot, not the
+ // size of x (which might be wider due to our dropping
+ // of narrowing conversions).
+ x = e.p.NewValue1(x.Line, OpStoreReg, loc.(LocalSlot).Type, x)
+ }
+ } else {
+ // Emit move from src to dst.
+ _, srcReg := src.(*Register)
+ if srcReg {
+ if dstReg {
+ x = e.p.NewValue1(c.Line, OpCopy, c.Type, c)
+ } else {
+ x = e.p.NewValue1(c.Line, OpStoreReg, loc.(LocalSlot).Type, c)
+ }
+ } else {
+ if dstReg {
+ x = e.p.NewValue1(c.Line, OpLoadReg, c.Type, c)
+ } else {
+ // mem->mem. Use temp register.
+
+ // Pre-clobber destination. This avoids the
+ // following situation:
+ // - v is currently held in R0 and stacktmp0.
+ // - We want to copy stacktmp1 to stacktmp0.
+ // - We choose R0 as the temporary register.
+ // During the copy, both R0 and stacktmp0 are
+ // clobbered, losing both copies of v. Oops!
+ // Erasing the destination early means R0 will not
+ // be chosen as the temp register, as it will then
+ // be the last copy of v.
+ e.erase(loc)
+
+ r := e.findRegFor(c.Type)
+ t := e.p.NewValue1(c.Line, OpLoadReg, c.Type, c)
+ e.set(r, vid, t, false)
+ x = e.p.NewValue1(c.Line, OpStoreReg, loc.(LocalSlot).Type, t)
+ }
+ }
+ }
+ e.set(loc, vid, x, true)
+ if splice != nil {
+ *splice = x
+ }
+ return true
+}
+
+// set changes the contents of location loc to hold the given value and its cached representative.
+func (e *edgeState) set(loc Location, vid ID, c *Value, final bool) {
+ e.s.f.setHome(c, loc)
+ e.erase(loc)
+ e.contents[loc] = contentRecord{vid, c, final}
+ a := e.cache[vid]
+ a = append(a, c)
+ e.cache[vid] = a
+ if r, ok := loc.(*Register); ok {
+ e.usedRegs |= regMask(1) << uint(r.Num)
+ if final {
+ e.finalRegs |= regMask(1) << uint(r.Num)
+ }
+ if len(a) == 1 {
+ e.uniqueRegs |= regMask(1) << uint(r.Num)
+ }
+ if len(a) == 2 {
+ if t, ok := e.s.f.getHome(a[0].ID).(*Register); ok {
+ e.uniqueRegs &^= regMask(1) << uint(t.Num)
+ }
+ }
+ }
+ if regDebug {
+ fmt.Printf("%s\n", c.LongString())
+ fmt.Printf("v%d now available in %s:%s\n", vid, loc.Name(), c)
+ }
+}
+
+// erase removes any user of loc.
+func (e *edgeState) erase(loc Location) {
+ cr := e.contents[loc]
+ if cr.c == nil {
+ return
+ }
+ vid := cr.vid
+
+ if cr.final {
+ // Add a destination to move this value back into place.
+ // Make sure it gets added to the tail of the destination queue
+ // so we make progress on other moves first.
+ e.extra = append(e.extra, dstRecord{loc, cr.vid, nil})
+ }
+
+ // Remove c from the list of cached values.
+ a := e.cache[vid]
+ for i, c := range a {
+ if e.s.f.getHome(c.ID) == loc {
+ if regDebug {
+ fmt.Printf("v%d no longer available in %s:%s\n", vid, loc.Name(), c)
+ }
+ a[i], a = a[len(a)-1], a[:len(a)-1]
+ break
+ }
+ }
+ e.cache[vid] = a
+
+ // Update register masks.
+ if r, ok := loc.(*Register); ok {
+ e.usedRegs &^= regMask(1) << uint(r.Num)
+ if cr.final {
+ e.finalRegs &^= regMask(1) << uint(r.Num)
+ }
+ }
+ if len(a) == 1 {
+ if r, ok := e.s.f.getHome(a[0].ID).(*Register); ok {
+ e.uniqueRegs |= regMask(1) << uint(r.Num)
+ }
+ }
+}
+
+// findRegFor finds a register we can use to make a temp copy of type typ.
+func (e *edgeState) findRegFor(typ Type) Location {
+ // Which registers are possibilities.
+ var m regMask
+ if typ.IsFloat() {
+ m = e.s.compatRegs(e.s.f.Config.fe.TypeFloat64())
+ } else {
+ m = e.s.compatRegs(e.s.f.Config.fe.TypeInt64())
+ }
+
+ // Pick a register. In priority order:
+ // 1) an unused register
+ // 2) a non-unique register not holding a final value
+ // 3) a non-unique register
+ x := m &^ e.usedRegs
+ if x != 0 {
+ return ®isters[pickReg(x)]
+ }
+ x = m &^ e.uniqueRegs &^ e.finalRegs
+ if x != 0 {
+ return ®isters[pickReg(x)]
+ }
+ x = m &^ e.uniqueRegs
+ if x != 0 {
+ return ®isters[pickReg(x)]
+ }
+
+ // No register is available. Allocate a temp location to spill a register to.
+ // The type of the slot is immaterial - it will not be live across
+ // any safepoint. Just use a type big enough to hold any register.
+ typ = e.s.f.Config.fe.TypeInt64()
+ t := LocalSlot{e.s.f.Config.fe.Auto(typ), typ, 0}
+ // TODO: reuse these slots.
+
+ // Pick a register to spill.
+ for vid, a := range e.cache {
+ for _, c := range a {
+ if r, ok := e.s.f.getHome(c.ID).(*Register); ok && m>>uint(r.Num)&1 != 0 {
+ x := e.p.NewValue1(c.Line, OpStoreReg, c.Type, c)
+ e.set(t, vid, x, false)
+ if regDebug {
+ fmt.Printf(" SPILL %s->%s %s\n", r.Name(), t.Name(), x.LongString())
+ }
+ // r will now be overwritten by the caller. At some point
+ // later, the newly saved value will be moved back to its
+ // final destination in processDest.
+ return r
+ }
+ }
+ }
+
+ fmt.Printf("m:%d unique:%d final:%d\n", m, e.uniqueRegs, e.finalRegs)
+ for vid, a := range e.cache {
+ for _, c := range a {
+ fmt.Printf("v%d: %s %s\n", vid, c, e.s.f.getHome(c.ID).Name())
+ }
+ }
+ e.s.f.Fatalf("can't find empty register on edge %s->%s", e.p, e.b)
+ return nil
+}
+
+func (v *Value) rematerializeable() bool {
+ if !opcodeTable[v.Op].rematerializeable {
+ return false
+ }
+ for _, a := range v.Args {
+ // SP and SB (generated by OpSP and OpSB) are always available.
+ if a.Op != OpSP && a.Op != OpSB {
+ return false
+ }
+ }
+ return true
+}
+
+type liveInfo struct {
+ ID ID // ID of variable
+ dist int32 // # of instructions before next use
+}
+
+// computeLive computes a map from block ID to a list of value IDs live at the end
+// of that block. Together with the value ID is a count of how many instructions
+// to the next use of that value. The resulting map is stored at s.live.
+// TODO: this could be quadratic if lots of variables are live across lots of
+// basic blocks. Figure out a way to make this function (or, more precisely, the user
+// of this function) require only linear size & time.
+func (s *regAllocState) computeLive() {
+ f := s.f
+ s.live = make([][]liveInfo, f.NumBlocks())
+ var phis []*Value
+
+ live := newSparseMap(f.NumValues())
+ t := newSparseMap(f.NumValues())
+
+ // Instead of iterating over f.Blocks, iterate over their postordering.
+ // Liveness information flows backward, so starting at the end
+ // increases the probability that we will stabilize quickly.
+ // TODO: Do a better job yet. Here's one possibility:
+ // Calculate the dominator tree and locate all strongly connected components.
+ // If a value is live in one block of an SCC, it is live in all.
+ // Walk the dominator tree from end to beginning, just once, treating SCC
+ // components as single blocks, duplicated calculated liveness information
+ // out to all of them.
+ po := postorder(f)
+ for {
+ changed := false
+
+ for _, b := range po {
+ // Start with known live values at the end of the block.
+ // Add len(b.Values) to adjust from end-of-block distance
+ // to beginning-of-block distance.
+ live.clear()
+ for _, e := range s.live[b.ID] {
+ live.set(e.ID, e.dist+int32(len(b.Values)))
+ }
+
+ // Mark control value as live
+ if b.Control != nil && s.values[b.Control.ID].needReg {
+ live.set(b.Control.ID, int32(len(b.Values)))
+ }
+
+ // Propagate backwards to the start of the block
+ // Assumes Values have been scheduled.
+ phis := phis[:0]
+ for i := len(b.Values) - 1; i >= 0; i-- {
+ v := b.Values[i]
+ live.remove(v.ID)
+ if v.Op == OpPhi {
+ // save phi ops for later
+ phis = append(phis, v)
+ continue
+ }
+ for _, a := range v.Args {
+ if s.values[a.ID].needReg {
+ live.set(a.ID, int32(i))
+ }
+ }
+ }
+
+ // For each predecessor of b, expand its list of live-at-end values.
+ // invariant: live contains the values live at the start of b (excluding phi inputs)
+ for i, p := range b.Preds {
+ // Compute additional distance for the edge.
+ const normalEdge = 10
+ const likelyEdge = 1
+ const unlikelyEdge = 100
+ // Note: delta must be at least 1 to distinguish the control
+ // value use from the first user in a successor block.
+ delta := int32(normalEdge)
+ if len(p.Succs) == 2 {
+ if p.Succs[0] == b && p.Likely == BranchLikely ||
+ p.Succs[1] == b && p.Likely == BranchUnlikely {
+ delta = likelyEdge
+ }
+ if p.Succs[0] == b && p.Likely == BranchUnlikely ||
+ p.Succs[1] == b && p.Likely == BranchLikely {
+ delta = unlikelyEdge
+ }
+ }
+
+ // Start t off with the previously known live values at the end of p.
+ t.clear()
+ for _, e := range s.live[p.ID] {
+ t.set(e.ID, e.dist)
+ }
+ update := false
+
+ // Add new live values from scanning this block.
+ for _, e := range live.contents() {
+ d := e.val + delta
+ if !t.contains(e.key) || d < t.get(e.key) {
+ update = true
+ t.set(e.key, d)
+ }
+ }
+ // Also add the correct arg from the saved phi values.
+ // All phis are at distance delta (we consider them
+ // simultaneously happening at the start of the block).
+ for _, v := range phis {
+ id := v.Args[i].ID
+ if s.values[id].needReg && !t.contains(id) || delta < t.get(id) {
+ update = true
+ t.set(id, delta)
+ }
+ }
+
+ if !update {
+ continue
+ }
+ // The live set has changed, update it.
+ l := s.live[p.ID][:0]
+ if cap(l) < t.size() {
+ l = make([]liveInfo, 0, t.size())
+ }
+ for _, e := range t.contents() {
+ l = append(l, liveInfo{e.key, e.val})
+ }
+ s.live[p.ID] = l
+ changed = true
+ }
+ }
+
+ if !changed {
+ break
+ }
+ }
+ if regDebug {
+ fmt.Println("live values at end of each block")
+ for _, b := range f.Blocks {
+ fmt.Printf(" %s:", b)
+ for _, x := range s.live[b.ID] {
+ fmt.Printf(" v%d", x.ID)
+ }
+ fmt.Println()
+ }
+ }
+}
+
+// reserved returns a mask of reserved registers.
+func (s *regAllocState) reserved() regMask {
+ var m regMask
+ if obj.Framepointer_enabled != 0 {
+ m |= 1 << 5 // BP
+ }
+ if s.f.Config.ctxt.Flag_dynlink {
+ m |= 1 << 15 // R15
+ }
+ return m
+}
diff --git a/src/cmd/compile/internal/ssa/regalloc_test.go b/src/cmd/compile/internal/ssa/regalloc_test.go
new file mode 100644
index 0000000..6f3f690
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/regalloc_test.go
@@ -0,0 +1,33 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func TestLiveControlOps(t *testing.T) {
+ c := testConfig(t)
+ f := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("x", OpAMD64MOVBconst, TypeInt8, 1, nil),
+ Valu("y", OpAMD64MOVBconst, TypeInt8, 2, nil),
+ Valu("a", OpAMD64TESTB, TypeFlags, 0, nil, "x", "y"),
+ Valu("b", OpAMD64TESTB, TypeFlags, 0, nil, "y", "x"),
+ Eq("a", "if", "exit"),
+ ),
+ Bloc("if",
+ Eq("b", "plain", "exit"),
+ ),
+ Bloc("plain",
+ Goto("exit"),
+ ),
+ Bloc("exit",
+ Exit("mem"),
+ ),
+ )
+ flagalloc(f.f)
+ regalloc(f.f)
+ checkFunc(f.f)
+}
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
new file mode 100644
index 0000000..60509d2
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -0,0 +1,261 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+ "math"
+)
+
+func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) {
+ // repeat rewrites until we find no more rewrites
+ var curb *Block
+ var curv *Value
+ defer func() {
+ if curb != nil {
+ curb.Fatalf("panic during rewrite of block %s\n", curb.LongString())
+ }
+ if curv != nil {
+ curv.Fatalf("panic during rewrite of value %s\n", curv.LongString())
+ // TODO(khr): print source location also
+ }
+ }()
+ config := f.Config
+ for {
+ change := false
+ for _, b := range f.Blocks {
+ if b.Kind == BlockDead {
+ continue
+ }
+ if b.Control != nil && b.Control.Op == OpCopy {
+ for b.Control.Op == OpCopy {
+ b.Control = b.Control.Args[0]
+ }
+ }
+ curb = b
+ if rb(b) {
+ change = true
+ }
+ curb = nil
+ for _, v := range b.Values {
+ copyelimValue(v)
+ change = phielimValue(v) || change
+
+ // apply rewrite function
+ curv = v
+ if rv(v, config) {
+ change = true
+ }
+ curv = nil
+ }
+ }
+ if !change {
+ return
+ }
+ }
+}
+
+// Common functions called from rewriting rules
+
+func is64BitFloat(t Type) bool {
+ return t.Size() == 8 && t.IsFloat()
+}
+
+func is32BitFloat(t Type) bool {
+ return t.Size() == 4 && t.IsFloat()
+}
+
+func is64BitInt(t Type) bool {
+ return t.Size() == 8 && t.IsInteger()
+}
+
+func is32BitInt(t Type) bool {
+ return t.Size() == 4 && t.IsInteger()
+}
+
+func is16BitInt(t Type) bool {
+ return t.Size() == 2 && t.IsInteger()
+}
+
+func is8BitInt(t Type) bool {
+ return t.Size() == 1 && t.IsInteger()
+}
+
+func isPtr(t Type) bool {
+ return t.IsPtr()
+}
+
+func isSigned(t Type) bool {
+ return t.IsSigned()
+}
+
+func typeSize(t Type) int64 {
+ return t.Size()
+}
+
+// addOff adds two int64 offsets. Fails if wraparound happens.
+func addOff(x, y int64) int64 {
+ z := x + y
+ // x and y have same sign and z has a different sign => overflow
+ if x^y >= 0 && x^z < 0 {
+ panic(fmt.Sprintf("offset overflow %d %d", x, y))
+ }
+ return z
+}
+
+// mergeSym merges two symbolic offsets. There is no real merging of
+// offsets, we just pick the non-nil one.
+func mergeSym(x, y interface{}) interface{} {
+ if x == nil {
+ return y
+ }
+ if y == nil {
+ return x
+ }
+ panic(fmt.Sprintf("mergeSym with two non-nil syms %s %s", x, y))
+ return nil
+}
+func canMergeSym(x, y interface{}) bool {
+ return x == nil || y == nil
+}
+
+func inBounds8(idx, len int64) bool { return int8(idx) >= 0 && int8(idx) < int8(len) }
+func inBounds16(idx, len int64) bool { return int16(idx) >= 0 && int16(idx) < int16(len) }
+func inBounds32(idx, len int64) bool { return int32(idx) >= 0 && int32(idx) < int32(len) }
+func inBounds64(idx, len int64) bool { return idx >= 0 && idx < len }
+func sliceInBounds32(idx, len int64) bool { return int32(idx) >= 0 && int32(idx) <= int32(len) }
+func sliceInBounds64(idx, len int64) bool { return idx >= 0 && idx <= len }
+
+// nlz returns the number of leading zeros.
+func nlz(x int64) int64 {
+ // log2(0) == 1, so nlz(0) == 64
+ return 63 - log2(x)
+}
+
+// ntz returns the number of trailing zeros.
+func ntz(x int64) int64 {
+ return 64 - nlz(^x&(x-1))
+}
+
+// nlo returns the number of leading ones.
+func nlo(x int64) int64 {
+ return nlz(^x)
+}
+
+// nto returns the number of trailing ones.
+func nto(x int64) int64 {
+ return ntz(^x)
+}
+
+// log2 returns logarithm in base of uint64(n), with log2(0) = -1.
+func log2(n int64) (l int64) {
+ l = -1
+ x := uint64(n)
+ for ; x >= 0x8000; x >>= 16 {
+ l += 16
+ }
+ if x >= 0x80 {
+ x >>= 8
+ l += 8
+ }
+ if x >= 0x8 {
+ x >>= 4
+ l += 4
+ }
+ if x >= 0x2 {
+ x >>= 2
+ l += 2
+ }
+ if x >= 0x1 {
+ l++
+ }
+ return
+}
+
+// isPowerOfTwo reports whether n is a power of 2.
+func isPowerOfTwo(n int64) bool {
+ return n > 0 && n&(n-1) == 0
+}
+
+// is32Bit reports whether n can be represented as a signed 32 bit integer.
+func is32Bit(n int64) bool {
+ return n == int64(int32(n))
+}
+
+// b2i translates a boolean value to 0 or 1 for assigning to auxInt.
+func b2i(b bool) int64 {
+ if b {
+ return 1
+ }
+ return 0
+}
+
+// f2i is used in the rules for storing a float in AuxInt.
+func f2i(f float64) int64 {
+ return int64(math.Float64bits(f))
+}
+
+// uaddOvf returns true if unsigned a+b would overflow.
+func uaddOvf(a, b int64) bool {
+ return uint64(a)+uint64(b) < uint64(a)
+}
+
+// isSamePtr reports whether p1 and p2 point to the same address.
+func isSamePtr(p1, p2 *Value) bool {
+ if p1 == p2 {
+ return true
+ }
+ // Aux isn't used in OffPtr, and AuxInt isn't currently used in
+ // Addr, but this still works as the values will be null/0
+ return (p1.Op == OpOffPtr || p1.Op == OpAddr) && p1.Op == p2.Op &&
+ p1.Aux == p2.Aux && p1.AuxInt == p2.AuxInt &&
+ p1.Args[0] == p2.Args[0]
+}
+
+// DUFFZERO consists of repeated blocks of 4 MOVUPSs + ADD,
+// See runtime/mkduff.go.
+const (
+ dzBlocks = 16 // number of MOV/ADD blocks
+ dzBlockLen = 4 // number of clears per block
+ dzBlockSize = 19 // size of instructions in a single block
+ dzMovSize = 4 // size of single MOV instruction w/ offset
+ dzAddSize = 4 // size of single ADD instruction
+ dzClearStep = 16 // number of bytes cleared by each MOV instruction
+
+ dzTailLen = 4 // number of final STOSQ instructions
+ dzTailSize = 2 // size of single STOSQ instruction
+
+ dzClearLen = dzClearStep * dzBlockLen // bytes cleared by one block
+ dzSize = dzBlocks * dzBlockSize
+)
+
+func duffStart(size int64) int64 {
+ x, _ := duff(size)
+ return x
+}
+func duffAdj(size int64) int64 {
+ _, x := duff(size)
+ return x
+}
+
+// duff returns the offset (from duffzero, in bytes) and pointer adjust (in bytes)
+// required to use the duffzero mechanism for a block of the given size.
+func duff(size int64) (int64, int64) {
+ if size < 32 || size > 1024 || size%dzClearStep != 0 {
+ panic("bad duffzero size")
+ }
+ // TODO: arch-dependent
+ steps := size / dzClearStep
+ blocks := steps / dzBlockLen
+ steps %= dzBlockLen
+ off := dzBlockSize * (dzBlocks - blocks)
+ var adj int64
+ if steps != 0 {
+ off -= dzAddSize
+ off -= dzMovSize * steps
+ adj -= dzClearStep * (dzBlockLen - steps)
+ }
+ return off, adj
+}
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
new file mode 100644
index 0000000..83fc437
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -0,0 +1,15394 @@
+// autogenerated from gen/AMD64.rules: do not edit!
+// generated with: cd gen; go run *.go
+
+package ssa
+
+import "math"
+
+var _ = math.MinInt8 // in case not otherwise used
+func rewriteValueAMD64(v *Value, config *Config) bool {
+ switch v.Op {
+ case OpAMD64ADDB:
+ return rewriteValueAMD64_OpAMD64ADDB(v, config)
+ case OpAMD64ADDBconst:
+ return rewriteValueAMD64_OpAMD64ADDBconst(v, config)
+ case OpAMD64ADDL:
+ return rewriteValueAMD64_OpAMD64ADDL(v, config)
+ case OpAMD64ADDLconst:
+ return rewriteValueAMD64_OpAMD64ADDLconst(v, config)
+ case OpAMD64ADDQ:
+ return rewriteValueAMD64_OpAMD64ADDQ(v, config)
+ case OpAMD64ADDQconst:
+ return rewriteValueAMD64_OpAMD64ADDQconst(v, config)
+ case OpAMD64ADDW:
+ return rewriteValueAMD64_OpAMD64ADDW(v, config)
+ case OpAMD64ADDWconst:
+ return rewriteValueAMD64_OpAMD64ADDWconst(v, config)
+ case OpAMD64ANDB:
+ return rewriteValueAMD64_OpAMD64ANDB(v, config)
+ case OpAMD64ANDBconst:
+ return rewriteValueAMD64_OpAMD64ANDBconst(v, config)
+ case OpAMD64ANDL:
+ return rewriteValueAMD64_OpAMD64ANDL(v, config)
+ case OpAMD64ANDLconst:
+ return rewriteValueAMD64_OpAMD64ANDLconst(v, config)
+ case OpAMD64ANDQ:
+ return rewriteValueAMD64_OpAMD64ANDQ(v, config)
+ case OpAMD64ANDQconst:
+ return rewriteValueAMD64_OpAMD64ANDQconst(v, config)
+ case OpAMD64ANDW:
+ return rewriteValueAMD64_OpAMD64ANDW(v, config)
+ case OpAMD64ANDWconst:
+ return rewriteValueAMD64_OpAMD64ANDWconst(v, config)
+ case OpAdd16:
+ return rewriteValueAMD64_OpAdd16(v, config)
+ case OpAdd32:
+ return rewriteValueAMD64_OpAdd32(v, config)
+ case OpAdd32F:
+ return rewriteValueAMD64_OpAdd32F(v, config)
+ case OpAdd64:
+ return rewriteValueAMD64_OpAdd64(v, config)
+ case OpAdd64F:
+ return rewriteValueAMD64_OpAdd64F(v, config)
+ case OpAdd8:
+ return rewriteValueAMD64_OpAdd8(v, config)
+ case OpAddPtr:
+ return rewriteValueAMD64_OpAddPtr(v, config)
+ case OpAddr:
+ return rewriteValueAMD64_OpAddr(v, config)
+ case OpAnd16:
+ return rewriteValueAMD64_OpAnd16(v, config)
+ case OpAnd32:
+ return rewriteValueAMD64_OpAnd32(v, config)
+ case OpAnd64:
+ return rewriteValueAMD64_OpAnd64(v, config)
+ case OpAnd8:
+ return rewriteValueAMD64_OpAnd8(v, config)
+ case OpAvg64u:
+ return rewriteValueAMD64_OpAvg64u(v, config)
+ case OpAMD64CMPB:
+ return rewriteValueAMD64_OpAMD64CMPB(v, config)
+ case OpAMD64CMPBconst:
+ return rewriteValueAMD64_OpAMD64CMPBconst(v, config)
+ case OpAMD64CMPL:
+ return rewriteValueAMD64_OpAMD64CMPL(v, config)
+ case OpAMD64CMPLconst:
+ return rewriteValueAMD64_OpAMD64CMPLconst(v, config)
+ case OpAMD64CMPQ:
+ return rewriteValueAMD64_OpAMD64CMPQ(v, config)
+ case OpAMD64CMPQconst:
+ return rewriteValueAMD64_OpAMD64CMPQconst(v, config)
+ case OpAMD64CMPW:
+ return rewriteValueAMD64_OpAMD64CMPW(v, config)
+ case OpAMD64CMPWconst:
+ return rewriteValueAMD64_OpAMD64CMPWconst(v, config)
+ case OpClosureCall:
+ return rewriteValueAMD64_OpClosureCall(v, config)
+ case OpCom16:
+ return rewriteValueAMD64_OpCom16(v, config)
+ case OpCom32:
+ return rewriteValueAMD64_OpCom32(v, config)
+ case OpCom64:
+ return rewriteValueAMD64_OpCom64(v, config)
+ case OpCom8:
+ return rewriteValueAMD64_OpCom8(v, config)
+ case OpConst16:
+ return rewriteValueAMD64_OpConst16(v, config)
+ case OpConst32:
+ return rewriteValueAMD64_OpConst32(v, config)
+ case OpConst32F:
+ return rewriteValueAMD64_OpConst32F(v, config)
+ case OpConst64:
+ return rewriteValueAMD64_OpConst64(v, config)
+ case OpConst64F:
+ return rewriteValueAMD64_OpConst64F(v, config)
+ case OpConst8:
+ return rewriteValueAMD64_OpConst8(v, config)
+ case OpConstBool:
+ return rewriteValueAMD64_OpConstBool(v, config)
+ case OpConstNil:
+ return rewriteValueAMD64_OpConstNil(v, config)
+ case OpConvert:
+ return rewriteValueAMD64_OpConvert(v, config)
+ case OpCvt32Fto32:
+ return rewriteValueAMD64_OpCvt32Fto32(v, config)
+ case OpCvt32Fto64:
+ return rewriteValueAMD64_OpCvt32Fto64(v, config)
+ case OpCvt32Fto64F:
+ return rewriteValueAMD64_OpCvt32Fto64F(v, config)
+ case OpCvt32to32F:
+ return rewriteValueAMD64_OpCvt32to32F(v, config)
+ case OpCvt32to64F:
+ return rewriteValueAMD64_OpCvt32to64F(v, config)
+ case OpCvt64Fto32:
+ return rewriteValueAMD64_OpCvt64Fto32(v, config)
+ case OpCvt64Fto32F:
+ return rewriteValueAMD64_OpCvt64Fto32F(v, config)
+ case OpCvt64Fto64:
+ return rewriteValueAMD64_OpCvt64Fto64(v, config)
+ case OpCvt64to32F:
+ return rewriteValueAMD64_OpCvt64to32F(v, config)
+ case OpCvt64to64F:
+ return rewriteValueAMD64_OpCvt64to64F(v, config)
+ case OpDeferCall:
+ return rewriteValueAMD64_OpDeferCall(v, config)
+ case OpDiv16:
+ return rewriteValueAMD64_OpDiv16(v, config)
+ case OpDiv16u:
+ return rewriteValueAMD64_OpDiv16u(v, config)
+ case OpDiv32:
+ return rewriteValueAMD64_OpDiv32(v, config)
+ case OpDiv32F:
+ return rewriteValueAMD64_OpDiv32F(v, config)
+ case OpDiv32u:
+ return rewriteValueAMD64_OpDiv32u(v, config)
+ case OpDiv64:
+ return rewriteValueAMD64_OpDiv64(v, config)
+ case OpDiv64F:
+ return rewriteValueAMD64_OpDiv64F(v, config)
+ case OpDiv64u:
+ return rewriteValueAMD64_OpDiv64u(v, config)
+ case OpDiv8:
+ return rewriteValueAMD64_OpDiv8(v, config)
+ case OpDiv8u:
+ return rewriteValueAMD64_OpDiv8u(v, config)
+ case OpEq16:
+ return rewriteValueAMD64_OpEq16(v, config)
+ case OpEq32:
+ return rewriteValueAMD64_OpEq32(v, config)
+ case OpEq32F:
+ return rewriteValueAMD64_OpEq32F(v, config)
+ case OpEq64:
+ return rewriteValueAMD64_OpEq64(v, config)
+ case OpEq64F:
+ return rewriteValueAMD64_OpEq64F(v, config)
+ case OpEq8:
+ return rewriteValueAMD64_OpEq8(v, config)
+ case OpEqPtr:
+ return rewriteValueAMD64_OpEqPtr(v, config)
+ case OpGeq16:
+ return rewriteValueAMD64_OpGeq16(v, config)
+ case OpGeq16U:
+ return rewriteValueAMD64_OpGeq16U(v, config)
+ case OpGeq32:
+ return rewriteValueAMD64_OpGeq32(v, config)
+ case OpGeq32F:
+ return rewriteValueAMD64_OpGeq32F(v, config)
+ case OpGeq32U:
+ return rewriteValueAMD64_OpGeq32U(v, config)
+ case OpGeq64:
+ return rewriteValueAMD64_OpGeq64(v, config)
+ case OpGeq64F:
+ return rewriteValueAMD64_OpGeq64F(v, config)
+ case OpGeq64U:
+ return rewriteValueAMD64_OpGeq64U(v, config)
+ case OpGeq8:
+ return rewriteValueAMD64_OpGeq8(v, config)
+ case OpGeq8U:
+ return rewriteValueAMD64_OpGeq8U(v, config)
+ case OpGetClosurePtr:
+ return rewriteValueAMD64_OpGetClosurePtr(v, config)
+ case OpGetG:
+ return rewriteValueAMD64_OpGetG(v, config)
+ case OpGoCall:
+ return rewriteValueAMD64_OpGoCall(v, config)
+ case OpGreater16:
+ return rewriteValueAMD64_OpGreater16(v, config)
+ case OpGreater16U:
+ return rewriteValueAMD64_OpGreater16U(v, config)
+ case OpGreater32:
+ return rewriteValueAMD64_OpGreater32(v, config)
+ case OpGreater32F:
+ return rewriteValueAMD64_OpGreater32F(v, config)
+ case OpGreater32U:
+ return rewriteValueAMD64_OpGreater32U(v, config)
+ case OpGreater64:
+ return rewriteValueAMD64_OpGreater64(v, config)
+ case OpGreater64F:
+ return rewriteValueAMD64_OpGreater64F(v, config)
+ case OpGreater64U:
+ return rewriteValueAMD64_OpGreater64U(v, config)
+ case OpGreater8:
+ return rewriteValueAMD64_OpGreater8(v, config)
+ case OpGreater8U:
+ return rewriteValueAMD64_OpGreater8U(v, config)
+ case OpHmul16:
+ return rewriteValueAMD64_OpHmul16(v, config)
+ case OpHmul16u:
+ return rewriteValueAMD64_OpHmul16u(v, config)
+ case OpHmul32:
+ return rewriteValueAMD64_OpHmul32(v, config)
+ case OpHmul32u:
+ return rewriteValueAMD64_OpHmul32u(v, config)
+ case OpHmul64:
+ return rewriteValueAMD64_OpHmul64(v, config)
+ case OpHmul64u:
+ return rewriteValueAMD64_OpHmul64u(v, config)
+ case OpHmul8:
+ return rewriteValueAMD64_OpHmul8(v, config)
+ case OpHmul8u:
+ return rewriteValueAMD64_OpHmul8u(v, config)
+ case OpITab:
+ return rewriteValueAMD64_OpITab(v, config)
+ case OpInterCall:
+ return rewriteValueAMD64_OpInterCall(v, config)
+ case OpIsInBounds:
+ return rewriteValueAMD64_OpIsInBounds(v, config)
+ case OpIsNonNil:
+ return rewriteValueAMD64_OpIsNonNil(v, config)
+ case OpIsSliceInBounds:
+ return rewriteValueAMD64_OpIsSliceInBounds(v, config)
+ case OpAMD64LEAQ:
+ return rewriteValueAMD64_OpAMD64LEAQ(v, config)
+ case OpAMD64LEAQ1:
+ return rewriteValueAMD64_OpAMD64LEAQ1(v, config)
+ case OpAMD64LEAQ2:
+ return rewriteValueAMD64_OpAMD64LEAQ2(v, config)
+ case OpAMD64LEAQ4:
+ return rewriteValueAMD64_OpAMD64LEAQ4(v, config)
+ case OpAMD64LEAQ8:
+ return rewriteValueAMD64_OpAMD64LEAQ8(v, config)
+ case OpLeq16:
+ return rewriteValueAMD64_OpLeq16(v, config)
+ case OpLeq16U:
+ return rewriteValueAMD64_OpLeq16U(v, config)
+ case OpLeq32:
+ return rewriteValueAMD64_OpLeq32(v, config)
+ case OpLeq32F:
+ return rewriteValueAMD64_OpLeq32F(v, config)
+ case OpLeq32U:
+ return rewriteValueAMD64_OpLeq32U(v, config)
+ case OpLeq64:
+ return rewriteValueAMD64_OpLeq64(v, config)
+ case OpLeq64F:
+ return rewriteValueAMD64_OpLeq64F(v, config)
+ case OpLeq64U:
+ return rewriteValueAMD64_OpLeq64U(v, config)
+ case OpLeq8:
+ return rewriteValueAMD64_OpLeq8(v, config)
+ case OpLeq8U:
+ return rewriteValueAMD64_OpLeq8U(v, config)
+ case OpLess16:
+ return rewriteValueAMD64_OpLess16(v, config)
+ case OpLess16U:
+ return rewriteValueAMD64_OpLess16U(v, config)
+ case OpLess32:
+ return rewriteValueAMD64_OpLess32(v, config)
+ case OpLess32F:
+ return rewriteValueAMD64_OpLess32F(v, config)
+ case OpLess32U:
+ return rewriteValueAMD64_OpLess32U(v, config)
+ case OpLess64:
+ return rewriteValueAMD64_OpLess64(v, config)
+ case OpLess64F:
+ return rewriteValueAMD64_OpLess64F(v, config)
+ case OpLess64U:
+ return rewriteValueAMD64_OpLess64U(v, config)
+ case OpLess8:
+ return rewriteValueAMD64_OpLess8(v, config)
+ case OpLess8U:
+ return rewriteValueAMD64_OpLess8U(v, config)
+ case OpLoad:
+ return rewriteValueAMD64_OpLoad(v, config)
+ case OpLrot16:
+ return rewriteValueAMD64_OpLrot16(v, config)
+ case OpLrot32:
+ return rewriteValueAMD64_OpLrot32(v, config)
+ case OpLrot64:
+ return rewriteValueAMD64_OpLrot64(v, config)
+ case OpLrot8:
+ return rewriteValueAMD64_OpLrot8(v, config)
+ case OpLsh16x16:
+ return rewriteValueAMD64_OpLsh16x16(v, config)
+ case OpLsh16x32:
+ return rewriteValueAMD64_OpLsh16x32(v, config)
+ case OpLsh16x64:
+ return rewriteValueAMD64_OpLsh16x64(v, config)
+ case OpLsh16x8:
+ return rewriteValueAMD64_OpLsh16x8(v, config)
+ case OpLsh32x16:
+ return rewriteValueAMD64_OpLsh32x16(v, config)
+ case OpLsh32x32:
+ return rewriteValueAMD64_OpLsh32x32(v, config)
+ case OpLsh32x64:
+ return rewriteValueAMD64_OpLsh32x64(v, config)
+ case OpLsh32x8:
+ return rewriteValueAMD64_OpLsh32x8(v, config)
+ case OpLsh64x16:
+ return rewriteValueAMD64_OpLsh64x16(v, config)
+ case OpLsh64x32:
+ return rewriteValueAMD64_OpLsh64x32(v, config)
+ case OpLsh64x64:
+ return rewriteValueAMD64_OpLsh64x64(v, config)
+ case OpLsh64x8:
+ return rewriteValueAMD64_OpLsh64x8(v, config)
+ case OpLsh8x16:
+ return rewriteValueAMD64_OpLsh8x16(v, config)
+ case OpLsh8x32:
+ return rewriteValueAMD64_OpLsh8x32(v, config)
+ case OpLsh8x64:
+ return rewriteValueAMD64_OpLsh8x64(v, config)
+ case OpLsh8x8:
+ return rewriteValueAMD64_OpLsh8x8(v, config)
+ case OpAMD64MOVBQSX:
+ return rewriteValueAMD64_OpAMD64MOVBQSX(v, config)
+ case OpAMD64MOVBQZX:
+ return rewriteValueAMD64_OpAMD64MOVBQZX(v, config)
+ case OpAMD64MOVBload:
+ return rewriteValueAMD64_OpAMD64MOVBload(v, config)
+ case OpAMD64MOVBloadidx1:
+ return rewriteValueAMD64_OpAMD64MOVBloadidx1(v, config)
+ case OpAMD64MOVBstore:
+ return rewriteValueAMD64_OpAMD64MOVBstore(v, config)
+ case OpAMD64MOVBstoreconst:
+ return rewriteValueAMD64_OpAMD64MOVBstoreconst(v, config)
+ case OpAMD64MOVBstoreconstidx1:
+ return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v, config)
+ case OpAMD64MOVBstoreidx1:
+ return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v, config)
+ case OpAMD64MOVLQSX:
+ return rewriteValueAMD64_OpAMD64MOVLQSX(v, config)
+ case OpAMD64MOVLQZX:
+ return rewriteValueAMD64_OpAMD64MOVLQZX(v, config)
+ case OpAMD64MOVLload:
+ return rewriteValueAMD64_OpAMD64MOVLload(v, config)
+ case OpAMD64MOVLloadidx4:
+ return rewriteValueAMD64_OpAMD64MOVLloadidx4(v, config)
+ case OpAMD64MOVLstore:
+ return rewriteValueAMD64_OpAMD64MOVLstore(v, config)
+ case OpAMD64MOVLstoreconst:
+ return rewriteValueAMD64_OpAMD64MOVLstoreconst(v, config)
+ case OpAMD64MOVLstoreconstidx4:
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v, config)
+ case OpAMD64MOVLstoreidx4:
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v, config)
+ case OpAMD64MOVOload:
+ return rewriteValueAMD64_OpAMD64MOVOload(v, config)
+ case OpAMD64MOVOstore:
+ return rewriteValueAMD64_OpAMD64MOVOstore(v, config)
+ case OpAMD64MOVQload:
+ return rewriteValueAMD64_OpAMD64MOVQload(v, config)
+ case OpAMD64MOVQloadidx8:
+ return rewriteValueAMD64_OpAMD64MOVQloadidx8(v, config)
+ case OpAMD64MOVQstore:
+ return rewriteValueAMD64_OpAMD64MOVQstore(v, config)
+ case OpAMD64MOVQstoreconst:
+ return rewriteValueAMD64_OpAMD64MOVQstoreconst(v, config)
+ case OpAMD64MOVQstoreconstidx8:
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v, config)
+ case OpAMD64MOVQstoreidx8:
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v, config)
+ case OpAMD64MOVSDload:
+ return rewriteValueAMD64_OpAMD64MOVSDload(v, config)
+ case OpAMD64MOVSDloadidx8:
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v, config)
+ case OpAMD64MOVSDstore:
+ return rewriteValueAMD64_OpAMD64MOVSDstore(v, config)
+ case OpAMD64MOVSDstoreidx8:
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v, config)
+ case OpAMD64MOVSSload:
+ return rewriteValueAMD64_OpAMD64MOVSSload(v, config)
+ case OpAMD64MOVSSloadidx4:
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v, config)
+ case OpAMD64MOVSSstore:
+ return rewriteValueAMD64_OpAMD64MOVSSstore(v, config)
+ case OpAMD64MOVSSstoreidx4:
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v, config)
+ case OpAMD64MOVWQSX:
+ return rewriteValueAMD64_OpAMD64MOVWQSX(v, config)
+ case OpAMD64MOVWQZX:
+ return rewriteValueAMD64_OpAMD64MOVWQZX(v, config)
+ case OpAMD64MOVWload:
+ return rewriteValueAMD64_OpAMD64MOVWload(v, config)
+ case OpAMD64MOVWloadidx2:
+ return rewriteValueAMD64_OpAMD64MOVWloadidx2(v, config)
+ case OpAMD64MOVWstore:
+ return rewriteValueAMD64_OpAMD64MOVWstore(v, config)
+ case OpAMD64MOVWstoreconst:
+ return rewriteValueAMD64_OpAMD64MOVWstoreconst(v, config)
+ case OpAMD64MOVWstoreconstidx2:
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v, config)
+ case OpAMD64MOVWstoreidx2:
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v, config)
+ case OpAMD64MULB:
+ return rewriteValueAMD64_OpAMD64MULB(v, config)
+ case OpAMD64MULBconst:
+ return rewriteValueAMD64_OpAMD64MULBconst(v, config)
+ case OpAMD64MULL:
+ return rewriteValueAMD64_OpAMD64MULL(v, config)
+ case OpAMD64MULLconst:
+ return rewriteValueAMD64_OpAMD64MULLconst(v, config)
+ case OpAMD64MULQ:
+ return rewriteValueAMD64_OpAMD64MULQ(v, config)
+ case OpAMD64MULQconst:
+ return rewriteValueAMD64_OpAMD64MULQconst(v, config)
+ case OpAMD64MULW:
+ return rewriteValueAMD64_OpAMD64MULW(v, config)
+ case OpAMD64MULWconst:
+ return rewriteValueAMD64_OpAMD64MULWconst(v, config)
+ case OpMod16:
+ return rewriteValueAMD64_OpMod16(v, config)
+ case OpMod16u:
+ return rewriteValueAMD64_OpMod16u(v, config)
+ case OpMod32:
+ return rewriteValueAMD64_OpMod32(v, config)
+ case OpMod32u:
+ return rewriteValueAMD64_OpMod32u(v, config)
+ case OpMod64:
+ return rewriteValueAMD64_OpMod64(v, config)
+ case OpMod64u:
+ return rewriteValueAMD64_OpMod64u(v, config)
+ case OpMod8:
+ return rewriteValueAMD64_OpMod8(v, config)
+ case OpMod8u:
+ return rewriteValueAMD64_OpMod8u(v, config)
+ case OpMove:
+ return rewriteValueAMD64_OpMove(v, config)
+ case OpMul16:
+ return rewriteValueAMD64_OpMul16(v, config)
+ case OpMul32:
+ return rewriteValueAMD64_OpMul32(v, config)
+ case OpMul32F:
+ return rewriteValueAMD64_OpMul32F(v, config)
+ case OpMul64:
+ return rewriteValueAMD64_OpMul64(v, config)
+ case OpMul64F:
+ return rewriteValueAMD64_OpMul64F(v, config)
+ case OpMul8:
+ return rewriteValueAMD64_OpMul8(v, config)
+ case OpAMD64NEGB:
+ return rewriteValueAMD64_OpAMD64NEGB(v, config)
+ case OpAMD64NEGL:
+ return rewriteValueAMD64_OpAMD64NEGL(v, config)
+ case OpAMD64NEGQ:
+ return rewriteValueAMD64_OpAMD64NEGQ(v, config)
+ case OpAMD64NEGW:
+ return rewriteValueAMD64_OpAMD64NEGW(v, config)
+ case OpAMD64NOTB:
+ return rewriteValueAMD64_OpAMD64NOTB(v, config)
+ case OpAMD64NOTL:
+ return rewriteValueAMD64_OpAMD64NOTL(v, config)
+ case OpAMD64NOTQ:
+ return rewriteValueAMD64_OpAMD64NOTQ(v, config)
+ case OpAMD64NOTW:
+ return rewriteValueAMD64_OpAMD64NOTW(v, config)
+ case OpNeg16:
+ return rewriteValueAMD64_OpNeg16(v, config)
+ case OpNeg32:
+ return rewriteValueAMD64_OpNeg32(v, config)
+ case OpNeg32F:
+ return rewriteValueAMD64_OpNeg32F(v, config)
+ case OpNeg64:
+ return rewriteValueAMD64_OpNeg64(v, config)
+ case OpNeg64F:
+ return rewriteValueAMD64_OpNeg64F(v, config)
+ case OpNeg8:
+ return rewriteValueAMD64_OpNeg8(v, config)
+ case OpNeq16:
+ return rewriteValueAMD64_OpNeq16(v, config)
+ case OpNeq32:
+ return rewriteValueAMD64_OpNeq32(v, config)
+ case OpNeq32F:
+ return rewriteValueAMD64_OpNeq32F(v, config)
+ case OpNeq64:
+ return rewriteValueAMD64_OpNeq64(v, config)
+ case OpNeq64F:
+ return rewriteValueAMD64_OpNeq64F(v, config)
+ case OpNeq8:
+ return rewriteValueAMD64_OpNeq8(v, config)
+ case OpNeqPtr:
+ return rewriteValueAMD64_OpNeqPtr(v, config)
+ case OpNilCheck:
+ return rewriteValueAMD64_OpNilCheck(v, config)
+ case OpNot:
+ return rewriteValueAMD64_OpNot(v, config)
+ case OpAMD64ORB:
+ return rewriteValueAMD64_OpAMD64ORB(v, config)
+ case OpAMD64ORBconst:
+ return rewriteValueAMD64_OpAMD64ORBconst(v, config)
+ case OpAMD64ORL:
+ return rewriteValueAMD64_OpAMD64ORL(v, config)
+ case OpAMD64ORLconst:
+ return rewriteValueAMD64_OpAMD64ORLconst(v, config)
+ case OpAMD64ORQ:
+ return rewriteValueAMD64_OpAMD64ORQ(v, config)
+ case OpAMD64ORQconst:
+ return rewriteValueAMD64_OpAMD64ORQconst(v, config)
+ case OpAMD64ORW:
+ return rewriteValueAMD64_OpAMD64ORW(v, config)
+ case OpAMD64ORWconst:
+ return rewriteValueAMD64_OpAMD64ORWconst(v, config)
+ case OpOffPtr:
+ return rewriteValueAMD64_OpOffPtr(v, config)
+ case OpOr16:
+ return rewriteValueAMD64_OpOr16(v, config)
+ case OpOr32:
+ return rewriteValueAMD64_OpOr32(v, config)
+ case OpOr64:
+ return rewriteValueAMD64_OpOr64(v, config)
+ case OpOr8:
+ return rewriteValueAMD64_OpOr8(v, config)
+ case OpRsh16Ux16:
+ return rewriteValueAMD64_OpRsh16Ux16(v, config)
+ case OpRsh16Ux32:
+ return rewriteValueAMD64_OpRsh16Ux32(v, config)
+ case OpRsh16Ux64:
+ return rewriteValueAMD64_OpRsh16Ux64(v, config)
+ case OpRsh16Ux8:
+ return rewriteValueAMD64_OpRsh16Ux8(v, config)
+ case OpRsh16x16:
+ return rewriteValueAMD64_OpRsh16x16(v, config)
+ case OpRsh16x32:
+ return rewriteValueAMD64_OpRsh16x32(v, config)
+ case OpRsh16x64:
+ return rewriteValueAMD64_OpRsh16x64(v, config)
+ case OpRsh16x8:
+ return rewriteValueAMD64_OpRsh16x8(v, config)
+ case OpRsh32Ux16:
+ return rewriteValueAMD64_OpRsh32Ux16(v, config)
+ case OpRsh32Ux32:
+ return rewriteValueAMD64_OpRsh32Ux32(v, config)
+ case OpRsh32Ux64:
+ return rewriteValueAMD64_OpRsh32Ux64(v, config)
+ case OpRsh32Ux8:
+ return rewriteValueAMD64_OpRsh32Ux8(v, config)
+ case OpRsh32x16:
+ return rewriteValueAMD64_OpRsh32x16(v, config)
+ case OpRsh32x32:
+ return rewriteValueAMD64_OpRsh32x32(v, config)
+ case OpRsh32x64:
+ return rewriteValueAMD64_OpRsh32x64(v, config)
+ case OpRsh32x8:
+ return rewriteValueAMD64_OpRsh32x8(v, config)
+ case OpRsh64Ux16:
+ return rewriteValueAMD64_OpRsh64Ux16(v, config)
+ case OpRsh64Ux32:
+ return rewriteValueAMD64_OpRsh64Ux32(v, config)
+ case OpRsh64Ux64:
+ return rewriteValueAMD64_OpRsh64Ux64(v, config)
+ case OpRsh64Ux8:
+ return rewriteValueAMD64_OpRsh64Ux8(v, config)
+ case OpRsh64x16:
+ return rewriteValueAMD64_OpRsh64x16(v, config)
+ case OpRsh64x32:
+ return rewriteValueAMD64_OpRsh64x32(v, config)
+ case OpRsh64x64:
+ return rewriteValueAMD64_OpRsh64x64(v, config)
+ case OpRsh64x8:
+ return rewriteValueAMD64_OpRsh64x8(v, config)
+ case OpRsh8Ux16:
+ return rewriteValueAMD64_OpRsh8Ux16(v, config)
+ case OpRsh8Ux32:
+ return rewriteValueAMD64_OpRsh8Ux32(v, config)
+ case OpRsh8Ux64:
+ return rewriteValueAMD64_OpRsh8Ux64(v, config)
+ case OpRsh8Ux8:
+ return rewriteValueAMD64_OpRsh8Ux8(v, config)
+ case OpRsh8x16:
+ return rewriteValueAMD64_OpRsh8x16(v, config)
+ case OpRsh8x32:
+ return rewriteValueAMD64_OpRsh8x32(v, config)
+ case OpRsh8x64:
+ return rewriteValueAMD64_OpRsh8x64(v, config)
+ case OpRsh8x8:
+ return rewriteValueAMD64_OpRsh8x8(v, config)
+ case OpAMD64SARB:
+ return rewriteValueAMD64_OpAMD64SARB(v, config)
+ case OpAMD64SARBconst:
+ return rewriteValueAMD64_OpAMD64SARBconst(v, config)
+ case OpAMD64SARL:
+ return rewriteValueAMD64_OpAMD64SARL(v, config)
+ case OpAMD64SARLconst:
+ return rewriteValueAMD64_OpAMD64SARLconst(v, config)
+ case OpAMD64SARQ:
+ return rewriteValueAMD64_OpAMD64SARQ(v, config)
+ case OpAMD64SARQconst:
+ return rewriteValueAMD64_OpAMD64SARQconst(v, config)
+ case OpAMD64SARW:
+ return rewriteValueAMD64_OpAMD64SARW(v, config)
+ case OpAMD64SARWconst:
+ return rewriteValueAMD64_OpAMD64SARWconst(v, config)
+ case OpAMD64SBBLcarrymask:
+ return rewriteValueAMD64_OpAMD64SBBLcarrymask(v, config)
+ case OpAMD64SBBQcarrymask:
+ return rewriteValueAMD64_OpAMD64SBBQcarrymask(v, config)
+ case OpAMD64SETA:
+ return rewriteValueAMD64_OpAMD64SETA(v, config)
+ case OpAMD64SETAE:
+ return rewriteValueAMD64_OpAMD64SETAE(v, config)
+ case OpAMD64SETB:
+ return rewriteValueAMD64_OpAMD64SETB(v, config)
+ case OpAMD64SETBE:
+ return rewriteValueAMD64_OpAMD64SETBE(v, config)
+ case OpAMD64SETEQ:
+ return rewriteValueAMD64_OpAMD64SETEQ(v, config)
+ case OpAMD64SETG:
+ return rewriteValueAMD64_OpAMD64SETG(v, config)
+ case OpAMD64SETGE:
+ return rewriteValueAMD64_OpAMD64SETGE(v, config)
+ case OpAMD64SETL:
+ return rewriteValueAMD64_OpAMD64SETL(v, config)
+ case OpAMD64SETLE:
+ return rewriteValueAMD64_OpAMD64SETLE(v, config)
+ case OpAMD64SETNE:
+ return rewriteValueAMD64_OpAMD64SETNE(v, config)
+ case OpAMD64SHLB:
+ return rewriteValueAMD64_OpAMD64SHLB(v, config)
+ case OpAMD64SHLL:
+ return rewriteValueAMD64_OpAMD64SHLL(v, config)
+ case OpAMD64SHLQ:
+ return rewriteValueAMD64_OpAMD64SHLQ(v, config)
+ case OpAMD64SHLW:
+ return rewriteValueAMD64_OpAMD64SHLW(v, config)
+ case OpAMD64SHRB:
+ return rewriteValueAMD64_OpAMD64SHRB(v, config)
+ case OpAMD64SHRL:
+ return rewriteValueAMD64_OpAMD64SHRL(v, config)
+ case OpAMD64SHRQ:
+ return rewriteValueAMD64_OpAMD64SHRQ(v, config)
+ case OpAMD64SHRW:
+ return rewriteValueAMD64_OpAMD64SHRW(v, config)
+ case OpAMD64SUBB:
+ return rewriteValueAMD64_OpAMD64SUBB(v, config)
+ case OpAMD64SUBBconst:
+ return rewriteValueAMD64_OpAMD64SUBBconst(v, config)
+ case OpAMD64SUBL:
+ return rewriteValueAMD64_OpAMD64SUBL(v, config)
+ case OpAMD64SUBLconst:
+ return rewriteValueAMD64_OpAMD64SUBLconst(v, config)
+ case OpAMD64SUBQ:
+ return rewriteValueAMD64_OpAMD64SUBQ(v, config)
+ case OpAMD64SUBQconst:
+ return rewriteValueAMD64_OpAMD64SUBQconst(v, config)
+ case OpAMD64SUBW:
+ return rewriteValueAMD64_OpAMD64SUBW(v, config)
+ case OpAMD64SUBWconst:
+ return rewriteValueAMD64_OpAMD64SUBWconst(v, config)
+ case OpSignExt16to32:
+ return rewriteValueAMD64_OpSignExt16to32(v, config)
+ case OpSignExt16to64:
+ return rewriteValueAMD64_OpSignExt16to64(v, config)
+ case OpSignExt32to64:
+ return rewriteValueAMD64_OpSignExt32to64(v, config)
+ case OpSignExt8to16:
+ return rewriteValueAMD64_OpSignExt8to16(v, config)
+ case OpSignExt8to32:
+ return rewriteValueAMD64_OpSignExt8to32(v, config)
+ case OpSignExt8to64:
+ return rewriteValueAMD64_OpSignExt8to64(v, config)
+ case OpSqrt:
+ return rewriteValueAMD64_OpSqrt(v, config)
+ case OpStaticCall:
+ return rewriteValueAMD64_OpStaticCall(v, config)
+ case OpStore:
+ return rewriteValueAMD64_OpStore(v, config)
+ case OpSub16:
+ return rewriteValueAMD64_OpSub16(v, config)
+ case OpSub32:
+ return rewriteValueAMD64_OpSub32(v, config)
+ case OpSub32F:
+ return rewriteValueAMD64_OpSub32F(v, config)
+ case OpSub64:
+ return rewriteValueAMD64_OpSub64(v, config)
+ case OpSub64F:
+ return rewriteValueAMD64_OpSub64F(v, config)
+ case OpSub8:
+ return rewriteValueAMD64_OpSub8(v, config)
+ case OpSubPtr:
+ return rewriteValueAMD64_OpSubPtr(v, config)
+ case OpTrunc16to8:
+ return rewriteValueAMD64_OpTrunc16to8(v, config)
+ case OpTrunc32to16:
+ return rewriteValueAMD64_OpTrunc32to16(v, config)
+ case OpTrunc32to8:
+ return rewriteValueAMD64_OpTrunc32to8(v, config)
+ case OpTrunc64to16:
+ return rewriteValueAMD64_OpTrunc64to16(v, config)
+ case OpTrunc64to32:
+ return rewriteValueAMD64_OpTrunc64to32(v, config)
+ case OpTrunc64to8:
+ return rewriteValueAMD64_OpTrunc64to8(v, config)
+ case OpAMD64XORB:
+ return rewriteValueAMD64_OpAMD64XORB(v, config)
+ case OpAMD64XORBconst:
+ return rewriteValueAMD64_OpAMD64XORBconst(v, config)
+ case OpAMD64XORL:
+ return rewriteValueAMD64_OpAMD64XORL(v, config)
+ case OpAMD64XORLconst:
+ return rewriteValueAMD64_OpAMD64XORLconst(v, config)
+ case OpAMD64XORQ:
+ return rewriteValueAMD64_OpAMD64XORQ(v, config)
+ case OpAMD64XORQconst:
+ return rewriteValueAMD64_OpAMD64XORQconst(v, config)
+ case OpAMD64XORW:
+ return rewriteValueAMD64_OpAMD64XORW(v, config)
+ case OpAMD64XORWconst:
+ return rewriteValueAMD64_OpAMD64XORWconst(v, config)
+ case OpXor16:
+ return rewriteValueAMD64_OpXor16(v, config)
+ case OpXor32:
+ return rewriteValueAMD64_OpXor32(v, config)
+ case OpXor64:
+ return rewriteValueAMD64_OpXor64(v, config)
+ case OpXor8:
+ return rewriteValueAMD64_OpXor8(v, config)
+ case OpZero:
+ return rewriteValueAMD64_OpZero(v, config)
+ case OpZeroExt16to32:
+ return rewriteValueAMD64_OpZeroExt16to32(v, config)
+ case OpZeroExt16to64:
+ return rewriteValueAMD64_OpZeroExt16to64(v, config)
+ case OpZeroExt32to64:
+ return rewriteValueAMD64_OpZeroExt32to64(v, config)
+ case OpZeroExt8to16:
+ return rewriteValueAMD64_OpZeroExt8to16(v, config)
+ case OpZeroExt8to32:
+ return rewriteValueAMD64_OpZeroExt8to32(v, config)
+ case OpZeroExt8to64:
+ return rewriteValueAMD64_OpZeroExt8to64(v, config)
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDB x (MOVBconst [c]))
+ // cond:
+ // result: (ADDBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ADDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDB (MOVBconst [c]) x)
+ // cond:
+ // result: (ADDBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ADDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDB x (NEGB y))
+ // cond:
+ // result: (SUBB x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64NEGB {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64SUBB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDBconst [c] x)
+ // cond: int8(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int8(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [c+d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (ADDBconst [c] (ADDBconst [d] x))
+ // cond:
+ // result: (ADDBconst [c+d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64ADDBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDBconst)
+ v.AuxInt = c + d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDL x (MOVLconst [c]))
+ // cond:
+ // result: (ADDLconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ADDLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDL (MOVLconst [c]) x)
+ // cond:
+ // result: (ADDLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ADDLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDL x (NEGL y))
+ // cond:
+ // result: (SUBL x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64NEGL {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64SUBL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDLconst [c] x)
+ // cond: int32(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int32(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [c+d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (ADDLconst [c] (ADDLconst [d] x))
+ // cond:
+ // result: (ADDLconst [c+d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64ADDLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDLconst)
+ v.AuxInt = c + d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (ADDQconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ADDQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (ADDQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ADDQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQ x (SHLQconst [3] y))
+ // cond:
+ // result: (LEAQ8 x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64SHLQconst {
+ break
+ }
+ if v.Args[1].AuxInt != 3 {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64LEAQ8)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (SHLQconst [2] y))
+ // cond:
+ // result: (LEAQ4 x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64SHLQconst {
+ break
+ }
+ if v.Args[1].AuxInt != 2 {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64LEAQ4)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (SHLQconst [1] y))
+ // cond:
+ // result: (LEAQ2 x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64SHLQconst {
+ break
+ }
+ if v.Args[1].AuxInt != 1 {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64LEAQ2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (ADDQ y y))
+ // cond:
+ // result: (LEAQ2 x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQ {
+ break
+ }
+ y := v.Args[1].Args[0]
+ if v.Args[1].Args[1] != y {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (ADDQ x y))
+ // cond:
+ // result: (LEAQ2 y x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQ {
+ break
+ }
+ if v.Args[1].Args[0] != x {
+ break
+ }
+ y := v.Args[1].Args[1]
+ v.reset(OpAMD64LEAQ2)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQ x (ADDQ y x))
+ // cond:
+ // result: (LEAQ2 y x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQ {
+ break
+ }
+ y := v.Args[1].Args[0]
+ if v.Args[1].Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQ (ADDQconst [c] x) y)
+ // cond:
+ // result: (LEAQ1 [c] x y)
+ for {
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (ADDQconst [c] y))
+ // cond:
+ // result: (LEAQ1 [c] x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (LEAQ [c] {s} y))
+ // cond: x.Op != OpSB && y.Op != OpSB
+ // result: (LEAQ1 [c] {s} x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64LEAQ {
+ break
+ }
+ c := v.Args[1].AuxInt
+ s := v.Args[1].Aux
+ y := v.Args[1].Args[0]
+ if !(x.Op != OpSB && y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ (LEAQ [c] {s} x) y)
+ // cond: x.Op != OpSB && y.Op != OpSB
+ // result: (LEAQ1 [c] {s} x y)
+ for {
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ c := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(x.Op != OpSB && y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQ x (NEGQ y))
+ // cond:
+ // result: (SUBQ x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64NEGQ {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64SUBQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDQconst [c] (ADDQ x y))
+ // cond:
+ // result: (LEAQ1 [c] x y)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64ADDQ {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQconst [c] (LEAQ [d] {s} x))
+ // cond:
+ // result: (LEAQ [c+d] {s} x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ d := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64LEAQ)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQconst [c] (LEAQ1 [d] {s} x y))
+ // cond:
+ // result: (LEAQ1 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64LEAQ1 {
+ break
+ }
+ d := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQconst [c] (LEAQ2 [d] {s} x y))
+ // cond:
+ // result: (LEAQ2 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64LEAQ2 {
+ break
+ }
+ d := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpAMD64LEAQ2)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQconst [c] (LEAQ4 [d] {s} x y))
+ // cond:
+ // result: (LEAQ4 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ d := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpAMD64LEAQ4)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQconst [c] (LEAQ8 [d] {s} x y))
+ // cond:
+ // result: (LEAQ8 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ d := v.Args[0].AuxInt
+ s := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpAMD64LEAQ8)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (ADDQconst [0] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [c+d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (ADDQconst [c] (ADDQconst [d] x))
+ // cond:
+ // result: (ADDQconst [c+d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDQconst)
+ v.AuxInt = c + d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDW x (MOVWconst [c]))
+ // cond:
+ // result: (ADDWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ADDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDW (MOVWconst [c]) x)
+ // cond:
+ // result: (ADDWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ADDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDW x (NEGW y))
+ // cond:
+ // result: (SUBW x y)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64NEGW {
+ break
+ }
+ y := v.Args[1].Args[0]
+ v.reset(OpAMD64SUBW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ADDWconst [c] x)
+ // cond: int16(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int16(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ADDWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [c+d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (ADDWconst [c] (ADDWconst [d] x))
+ // cond:
+ // result: (ADDWconst [c+d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64ADDWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDWconst)
+ v.AuxInt = c + d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDB x (MOVLconst [c]))
+ // cond:
+ // result: (ANDBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ANDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDB (MOVLconst [c]) x)
+ // cond:
+ // result: (ANDBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ANDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDB x (MOVBconst [c]))
+ // cond:
+ // result: (ANDBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ANDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDB (MOVBconst [c]) x)
+ // cond:
+ // result: (ANDBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ANDBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDB x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDBconst [c] _)
+ // cond: int8(c)==0
+ // result: (MOVBconst [0])
+ for {
+ c := v.AuxInt
+ if !(int8(c) == 0) {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (ANDBconst [c] x)
+ // cond: int8(c)==-1
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int8(c) == -1) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [c&d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = c & d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDL x (MOVLconst [c]))
+ // cond:
+ // result: (ANDLconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ANDLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDL (MOVLconst [c]) x)
+ // cond:
+ // result: (ANDLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ANDLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDL x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDLconst [c] _)
+ // cond: int32(c)==0
+ // result: (MOVLconst [0])
+ for {
+ c := v.AuxInt
+ if !(int32(c) == 0) {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (ANDLconst [c] x)
+ // cond: int32(c)==-1
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int32(c) == -1) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [c&d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = c & d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (ANDQconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (ANDQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDQ x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDQconst [0] _)
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (ANDQconst [-1] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != -1 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [c&d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = c & d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDW x (MOVLconst [c]))
+ // cond:
+ // result: (ANDWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ANDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDW (MOVLconst [c]) x)
+ // cond:
+ // result: (ANDWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ANDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDW x (MOVWconst [c]))
+ // cond:
+ // result: (ANDWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ANDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDW (MOVWconst [c]) x)
+ // cond:
+ // result: (ANDWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ANDWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDW x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ANDWconst [c] _)
+ // cond: int16(c)==0
+ // result: (MOVWconst [0])
+ for {
+ c := v.AuxInt
+ if !(int16(c) == 0) {
+ break
+ }
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (ANDWconst [c] x)
+ // cond: int16(c)==-1
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int16(c) == -1) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ANDWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [c&d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = c & d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add16 x y)
+ // cond:
+ // result: (ADDW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add32 x y)
+ // cond:
+ // result: (ADDL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add32F x y)
+ // cond:
+ // result: (ADDSS x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDSS)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add64 x y)
+ // cond:
+ // result: (ADDQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add64F x y)
+ // cond:
+ // result: (ADDSD x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDSD)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add8 x y)
+ // cond:
+ // result: (ADDB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (AddPtr x y)
+ // cond:
+ // result: (ADDQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ADDQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Addr {sym} base)
+ // cond:
+ // result: (LEAQ {sym} base)
+ for {
+ sym := v.Aux
+ base := v.Args[0]
+ v.reset(OpAMD64LEAQ)
+ v.Aux = sym
+ v.AddArg(base)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And16 x y)
+ // cond:
+ // result: (ANDW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And32 x y)
+ // cond:
+ // result: (ANDL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And64 x y)
+ // cond:
+ // result: (ANDQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And8 x y)
+ // cond:
+ // result: (ANDB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAvg64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Avg64u x y)
+ // cond:
+ // result: (AVGQU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64AVGQU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPB x (MOVBconst [c]))
+ // cond:
+ // result: (CMPBconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64CMPBconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (CMPB (MOVBconst [c]) x)
+ // cond:
+ // result: (InvertFlags (CMPBconst x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64InvertFlags)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPBconst (MOVBconst [x]) [y])
+ // cond: int8(x)==int8(y)
+ // result: (FlagEQ)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int8(x) == int8(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagEQ)
+ return true
+ }
+ // match: (CMPBconst (MOVBconst [x]) [y])
+ // cond: int8(x)<int8(y) && uint8(x)<uint8(y)
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int8(x) < int8(y) && uint8(x) < uint8(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPBconst (MOVBconst [x]) [y])
+ // cond: int8(x)<int8(y) && uint8(x)>uint8(y)
+ // result: (FlagLT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int8(x) < int8(y) && uint8(x) > uint8(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_UGT)
+ return true
+ }
+ // match: (CMPBconst (MOVBconst [x]) [y])
+ // cond: int8(x)>int8(y) && uint8(x)<uint8(y)
+ // result: (FlagGT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int8(x) > int8(y) && uint8(x) < uint8(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_ULT)
+ return true
+ }
+ // match: (CMPBconst (MOVBconst [x]) [y])
+ // cond: int8(x)>int8(y) && uint8(x)>uint8(y)
+ // result: (FlagGT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int8(x) > int8(y) && uint8(x) > uint8(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_UGT)
+ return true
+ }
+ // match: (CMPBconst (ANDBconst _ [m]) [n])
+ // cond: int8(m)+1==int8(n) && isPowerOfTwo(int64(int8(n)))
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64ANDBconst {
+ break
+ }
+ m := v.Args[0].AuxInt
+ n := v.AuxInt
+ if !(int8(m)+1 == int8(n) && isPowerOfTwo(int64(int8(n)))) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPBconst (ANDB x y) [0])
+ // cond:
+ // result: (TESTB x y)
+ for {
+ if v.Args[0].Op != OpAMD64ANDB {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (CMPBconst (ANDBconst [c] x) [0])
+ // cond:
+ // result: (TESTBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPL x (MOVLconst [c]))
+ // cond:
+ // result: (CMPLconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64CMPLconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (CMPL (MOVLconst [c]) x)
+ // cond:
+ // result: (InvertFlags (CMPLconst x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64InvertFlags)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPLconst (MOVLconst [x]) [y])
+ // cond: int32(x)==int32(y)
+ // result: (FlagEQ)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int32(x) == int32(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagEQ)
+ return true
+ }
+ // match: (CMPLconst (MOVLconst [x]) [y])
+ // cond: int32(x)<int32(y) && uint32(x)<uint32(y)
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int32(x) < int32(y) && uint32(x) < uint32(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPLconst (MOVLconst [x]) [y])
+ // cond: int32(x)<int32(y) && uint32(x)>uint32(y)
+ // result: (FlagLT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int32(x) < int32(y) && uint32(x) > uint32(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_UGT)
+ return true
+ }
+ // match: (CMPLconst (MOVLconst [x]) [y])
+ // cond: int32(x)>int32(y) && uint32(x)<uint32(y)
+ // result: (FlagGT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int32(x) > int32(y) && uint32(x) < uint32(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_ULT)
+ return true
+ }
+ // match: (CMPLconst (MOVLconst [x]) [y])
+ // cond: int32(x)>int32(y) && uint32(x)>uint32(y)
+ // result: (FlagGT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int32(x) > int32(y) && uint32(x) > uint32(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_UGT)
+ return true
+ }
+ // match: (CMPLconst (ANDLconst _ [m]) [n])
+ // cond: int32(m)+1==int32(n) && isPowerOfTwo(int64(int32(n)))
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64ANDLconst {
+ break
+ }
+ m := v.Args[0].AuxInt
+ n := v.AuxInt
+ if !(int32(m)+1 == int32(n) && isPowerOfTwo(int64(int32(n)))) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPLconst (ANDL x y) [0])
+ // cond:
+ // result: (TESTL x y)
+ for {
+ if v.Args[0].Op != OpAMD64ANDL {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (CMPLconst (ANDLconst [c] x) [0])
+ // cond:
+ // result: (TESTLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (CMPQconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64CMPQconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (CMPQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (InvertFlags (CMPQconst x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64InvertFlags)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPQconst (MOVQconst [x]) [y])
+ // cond: x==y
+ // result: (FlagEQ)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(x == y) {
+ break
+ }
+ v.reset(OpAMD64FlagEQ)
+ return true
+ }
+ // match: (CMPQconst (MOVQconst [x]) [y])
+ // cond: x<y && uint64(x)<uint64(y)
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(x < y && uint64(x) < uint64(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPQconst (MOVQconst [x]) [y])
+ // cond: x<y && uint64(x)>uint64(y)
+ // result: (FlagLT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(x < y && uint64(x) > uint64(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_UGT)
+ return true
+ }
+ // match: (CMPQconst (MOVQconst [x]) [y])
+ // cond: x>y && uint64(x)<uint64(y)
+ // result: (FlagGT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(x > y && uint64(x) < uint64(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_ULT)
+ return true
+ }
+ // match: (CMPQconst (MOVQconst [x]) [y])
+ // cond: x>y && uint64(x)>uint64(y)
+ // result: (FlagGT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(x > y && uint64(x) > uint64(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_UGT)
+ return true
+ }
+ // match: (CMPQconst (ANDQconst _ [m]) [n])
+ // cond: m+1==n && isPowerOfTwo(n)
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64ANDQconst {
+ break
+ }
+ m := v.Args[0].AuxInt
+ n := v.AuxInt
+ if !(m+1 == n && isPowerOfTwo(n)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPQconst (ANDQ x y) [0])
+ // cond:
+ // result: (TESTQ x y)
+ for {
+ if v.Args[0].Op != OpAMD64ANDQ {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (CMPQconst (ANDQconst [c] x) [0])
+ // cond:
+ // result: (TESTQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPW x (MOVWconst [c]))
+ // cond:
+ // result: (CMPWconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64CMPWconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (CMPW (MOVWconst [c]) x)
+ // cond:
+ // result: (InvertFlags (CMPWconst x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64InvertFlags)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (CMPWconst (MOVWconst [x]) [y])
+ // cond: int16(x)==int16(y)
+ // result: (FlagEQ)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int16(x) == int16(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagEQ)
+ return true
+ }
+ // match: (CMPWconst (MOVWconst [x]) [y])
+ // cond: int16(x)<int16(y) && uint16(x)<uint16(y)
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int16(x) < int16(y) && uint16(x) < uint16(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPWconst (MOVWconst [x]) [y])
+ // cond: int16(x)<int16(y) && uint16(x)>uint16(y)
+ // result: (FlagLT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int16(x) < int16(y) && uint16(x) > uint16(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_UGT)
+ return true
+ }
+ // match: (CMPWconst (MOVWconst [x]) [y])
+ // cond: int16(x)>int16(y) && uint16(x)<uint16(y)
+ // result: (FlagGT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int16(x) > int16(y) && uint16(x) < uint16(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_ULT)
+ return true
+ }
+ // match: (CMPWconst (MOVWconst [x]) [y])
+ // cond: int16(x)>int16(y) && uint16(x)>uint16(y)
+ // result: (FlagGT_UGT)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ x := v.Args[0].AuxInt
+ y := v.AuxInt
+ if !(int16(x) > int16(y) && uint16(x) > uint16(y)) {
+ break
+ }
+ v.reset(OpAMD64FlagGT_UGT)
+ return true
+ }
+ // match: (CMPWconst (ANDWconst _ [m]) [n])
+ // cond: int16(m)+1==int16(n) && isPowerOfTwo(int64(int16(n)))
+ // result: (FlagLT_ULT)
+ for {
+ if v.Args[0].Op != OpAMD64ANDWconst {
+ break
+ }
+ m := v.Args[0].AuxInt
+ n := v.AuxInt
+ if !(int16(m)+1 == int16(n) && isPowerOfTwo(int64(int16(n)))) {
+ break
+ }
+ v.reset(OpAMD64FlagLT_ULT)
+ return true
+ }
+ // match: (CMPWconst (ANDW x y) [0])
+ // cond:
+ // result: (TESTW x y)
+ for {
+ if v.Args[0].Op != OpAMD64ANDW {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (CMPWconst (ANDWconst [c] x) [0])
+ // cond:
+ // result: (TESTWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64TESTWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ClosureCall [argwid] entry closure mem)
+ // cond:
+ // result: (CALLclosure [argwid] entry closure mem)
+ for {
+ argwid := v.AuxInt
+ entry := v.Args[0]
+ closure := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64CALLclosure)
+ v.AuxInt = argwid
+ v.AddArg(entry)
+ v.AddArg(closure)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com16 x)
+ // cond:
+ // result: (NOTW x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NOTW)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com32 x)
+ // cond:
+ // result: (NOTL x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NOTL)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com64 x)
+ // cond:
+ // result: (NOTQ x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NOTQ)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com8 x)
+ // cond:
+ // result: (NOTB x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NOTB)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const16 [val])
+ // cond:
+ // result: (MOVWconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const32 [val])
+ // cond:
+ // result: (MOVLconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const32F [val])
+ // cond:
+ // result: (MOVSSconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVSSconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const64 [val])
+ // cond:
+ // result: (MOVQconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const64F [val])
+ // cond:
+ // result: (MOVSDconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVSDconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Const8 [val])
+ // cond:
+ // result: (MOVBconst [val])
+ for {
+ val := v.AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = val
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ConstBool [b])
+ // cond:
+ // result: (MOVBconst [b])
+ for {
+ b := v.AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = b
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ConstNil)
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Convert <t> x mem)
+ // cond:
+ // result: (MOVQconvert <t> x mem)
+ for {
+ t := v.Type
+ x := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQconvert)
+ v.Type = t
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt32Fto32 x)
+ // cond:
+ // result: (CVTTSS2SL x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTTSS2SL)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt32Fto64 x)
+ // cond:
+ // result: (CVTTSS2SQ x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTTSS2SQ)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt32Fto64F x)
+ // cond:
+ // result: (CVTSS2SD x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSS2SD)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt32to32F x)
+ // cond:
+ // result: (CVTSL2SS x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSL2SS)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt32to64F x)
+ // cond:
+ // result: (CVTSL2SD x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSL2SD)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt64Fto32 x)
+ // cond:
+ // result: (CVTTSD2SL x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTTSD2SL)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt64Fto32F x)
+ // cond:
+ // result: (CVTSD2SS x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSD2SS)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt64Fto64 x)
+ // cond:
+ // result: (CVTTSD2SQ x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTTSD2SQ)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt64to32F x)
+ // cond:
+ // result: (CVTSQ2SS x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSQ2SS)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Cvt64to64F x)
+ // cond:
+ // result: (CVTSQ2SD x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64CVTSQ2SD)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (DeferCall [argwid] mem)
+ // cond:
+ // result: (CALLdefer [argwid] mem)
+ for {
+ argwid := v.AuxInt
+ mem := v.Args[0]
+ v.reset(OpAMD64CALLdefer)
+ v.AuxInt = argwid
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div16 x y)
+ // cond:
+ // result: (DIVW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div16u x y)
+ // cond:
+ // result: (DIVWU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVWU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div32 x y)
+ // cond:
+ // result: (DIVL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div32F x y)
+ // cond:
+ // result: (DIVSS x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVSS)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div32u x y)
+ // cond:
+ // result: (DIVLU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVLU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div64 x y)
+ // cond:
+ // result: (DIVQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div64F x y)
+ // cond:
+ // result: (DIVSD x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVSD)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div64u x y)
+ // cond:
+ // result: (DIVQU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVQU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div8 x y)
+ // cond:
+ // result: (DIVW (SignExt8to16 x) (SignExt8to16 y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVW)
+ v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div8u x y)
+ // cond:
+ // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64DIVWU)
+ v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq16 x y)
+ // cond:
+ // result: (SETEQ (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQ)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq32 x y)
+ // cond:
+ // result: (SETEQ (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQ)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq32F x y)
+ // cond:
+ // result: (SETEQF (UCOMISS x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq64 x y)
+ // cond:
+ // result: (SETEQ (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQ)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq64F x y)
+ // cond:
+ // result: (SETEQF (UCOMISD x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq8 x y)
+ // cond:
+ // result: (SETEQ (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQ)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (EqPtr x y)
+ // cond:
+ // result: (SETEQ (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETEQ)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq16 x y)
+ // cond:
+ // result: (SETGE (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq16U x y)
+ // cond:
+ // result: (SETAE (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETAE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq32 x y)
+ // cond:
+ // result: (SETGE (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq32F x y)
+ // cond:
+ // result: (SETGEF (UCOMISS x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq32U x y)
+ // cond:
+ // result: (SETAE (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETAE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq64 x y)
+ // cond:
+ // result: (SETGE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq64F x y)
+ // cond:
+ // result: (SETGEF (UCOMISD x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq64U x y)
+ // cond:
+ // result: (SETAE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETAE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq8 x y)
+ // cond:
+ // result: (SETGE (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq8U x y)
+ // cond:
+ // result: (SETAE (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETAE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (GetClosurePtr)
+ // cond:
+ // result: (LoweredGetClosurePtr)
+ for {
+ v.reset(OpAMD64LoweredGetClosurePtr)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (GetG mem)
+ // cond:
+ // result: (LoweredGetG mem)
+ for {
+ mem := v.Args[0]
+ v.reset(OpAMD64LoweredGetG)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (GoCall [argwid] mem)
+ // cond:
+ // result: (CALLgo [argwid] mem)
+ for {
+ argwid := v.AuxInt
+ mem := v.Args[0]
+ v.reset(OpAMD64CALLgo)
+ v.AuxInt = argwid
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater16 x y)
+ // cond:
+ // result: (SETG (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETG)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater16U x y)
+ // cond:
+ // result: (SETA (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETA)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater32 x y)
+ // cond:
+ // result: (SETG (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETG)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater32F x y)
+ // cond:
+ // result: (SETGF (UCOMISS x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater32U x y)
+ // cond:
+ // result: (SETA (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETA)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater64 x y)
+ // cond:
+ // result: (SETG (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETG)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater64F x y)
+ // cond:
+ // result: (SETGF (UCOMISD x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater64U x y)
+ // cond:
+ // result: (SETA (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETA)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater8 x y)
+ // cond:
+ // result: (SETG (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETG)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater8U x y)
+ // cond:
+ // result: (SETA (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETA)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul16 x y)
+ // cond:
+ // result: (HMULW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul16u x y)
+ // cond:
+ // result: (HMULWU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULWU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul32 x y)
+ // cond:
+ // result: (HMULL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul32u x y)
+ // cond:
+ // result: (HMULLU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULLU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul64 x y)
+ // cond:
+ // result: (HMULQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul64u x y)
+ // cond:
+ // result: (HMULQU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULQU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul8 x y)
+ // cond:
+ // result: (HMULB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Hmul8u x y)
+ // cond:
+ // result: (HMULBU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64HMULBU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpITab(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ITab (Load ptr mem))
+ // cond:
+ // result: (MOVQload ptr mem)
+ for {
+ if v.Args[0].Op != OpLoad {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ v.reset(OpAMD64MOVQload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (InterCall [argwid] entry mem)
+ // cond:
+ // result: (CALLinter [argwid] entry mem)
+ for {
+ argwid := v.AuxInt
+ entry := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64CALLinter)
+ v.AuxInt = argwid
+ v.AddArg(entry)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IsInBounds idx len)
+ // cond:
+ // result: (SETB (CMPQ idx len))
+ for {
+ idx := v.Args[0]
+ len := v.Args[1]
+ v.reset(OpAMD64SETB)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(idx)
+ v0.AddArg(len)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IsNonNil p)
+ // cond:
+ // result: (SETNE (TESTQ p p))
+ for {
+ p := v.Args[0]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeFlags)
+ v0.AddArg(p)
+ v0.AddArg(p)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IsSliceInBounds idx len)
+ // cond:
+ // result: (SETBE (CMPQ idx len))
+ for {
+ idx := v.Args[0]
+ len := v.Args[1]
+ v.reset(OpAMD64SETBE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(idx)
+ v0.AddArg(len)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (LEAQ [c] {s} (ADDQconst [d] x))
+ // cond:
+ // result: (LEAQ [c+d] {s} x)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64LEAQ)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ return true
+ }
+ // match: (LEAQ [c] {s} (ADDQ x y))
+ // cond: x.Op != OpSB && y.Op != OpSB
+ // result: (LEAQ1 [c] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQ {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if !(x.Op != OpSB && y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x))
+ // cond: canMergeSym(sym1, sym2)
+ // result: (LEAQ [addOff(off1,off2)] {mergeSym(sym1,sym2)} x)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64LEAQ)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ return true
+ }
+ // match: (LEAQ [off1] {sym1} (LEAQ1 [off2] {sym2} x y))
+ // cond: canMergeSym(sym1, sym2)
+ // result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ1 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ [off1] {sym1} (LEAQ2 [off2] {sym2} x y))
+ // cond: canMergeSym(sym1, sym2)
+ // result: (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ2 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ [off1] {sym1} (LEAQ4 [off2] {sym2} x y))
+ // cond: canMergeSym(sym1, sym2)
+ // result: (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64LEAQ4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ [off1] {sym1} (LEAQ8 [off2] {sym2} x y))
+ // cond: canMergeSym(sym1, sym2)
+ // result: (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64LEAQ8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
+ // cond: x.Op != OpSB
+ // result: (LEAQ1 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ1 [c] {s} x (ADDQconst [d] y))
+ // cond: y.Op != OpSB
+ // result: (LEAQ1 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ y := v.Args[1].Args[0]
+ if !(y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ1 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
+ // cond: canMergeSym(sym1, sym2) && x.Op != OpSB
+ // result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ1 [off1] {sym1} x (LEAQ [off2] {sym2} y))
+ // cond: canMergeSym(sym1, sym2) && y.Op != OpSB
+ // result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[1].AuxInt
+ sym2 := v.Args[1].Aux
+ y := v.Args[1].Args[0]
+ if !(canMergeSym(sym1, sym2) && y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ1)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
+ // cond: x.Op != OpSB
+ // result: (LEAQ2 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ2 [c] {s} x (ADDQconst [d] y))
+ // cond: y.Op != OpSB
+ // result: (LEAQ2 [c+2*d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ y := v.Args[1].Args[0]
+ if !(y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AuxInt = c + 2*d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ2 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
+ // cond: canMergeSym(sym1, sym2) && x.Op != OpSB
+ // result: (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ2)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
+ // cond: x.Op != OpSB
+ // result: (LEAQ4 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ4)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ4 [c] {s} x (ADDQconst [d] y))
+ // cond: y.Op != OpSB
+ // result: (LEAQ4 [c+4*d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ y := v.Args[1].Args[0]
+ if !(y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ4)
+ v.AuxInt = c + 4*d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ4 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
+ // cond: canMergeSym(sym1, sym2) && x.Op != OpSB
+ // result: (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
+ // cond: x.Op != OpSB
+ // result: (LEAQ8 [c+d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ8)
+ v.AuxInt = c + d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ8 [c] {s} x (ADDQconst [d] y))
+ // cond: y.Op != OpSB
+ // result: (LEAQ8 [c+8*d] {s} x y)
+ for {
+ c := v.AuxInt
+ s := v.Aux
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ y := v.Args[1].Args[0]
+ if !(y.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ8)
+ v.AuxInt = c + 8*d
+ v.Aux = s
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ // match: (LEAQ8 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
+ // cond: canMergeSym(sym1, sym2) && x.Op != OpSB
+ // result: (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ x := v.Args[0].Args[0]
+ y := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64LEAQ8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq16 x y)
+ // cond:
+ // result: (SETLE (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETLE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq16U x y)
+ // cond:
+ // result: (SETBE (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETBE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq32 x y)
+ // cond:
+ // result: (SETLE (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETLE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq32F x y)
+ // cond:
+ // result: (SETGEF (UCOMISS y x))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(y)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq32U x y)
+ // cond:
+ // result: (SETBE (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETBE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq64 x y)
+ // cond:
+ // result: (SETLE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETLE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq64F x y)
+ // cond:
+ // result: (SETGEF (UCOMISD y x))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(y)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq64U x y)
+ // cond:
+ // result: (SETBE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETBE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq8 x y)
+ // cond:
+ // result: (SETLE (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETLE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq8U x y)
+ // cond:
+ // result: (SETBE (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETBE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less16 x y)
+ // cond:
+ // result: (SETL (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETL)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less16U x y)
+ // cond:
+ // result: (SETB (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETB)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less32 x y)
+ // cond:
+ // result: (SETL (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETL)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less32F x y)
+ // cond:
+ // result: (SETGF (UCOMISS y x))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(y)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less32U x y)
+ // cond:
+ // result: (SETB (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETB)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less64 x y)
+ // cond:
+ // result: (SETL (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETL)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less64F x y)
+ // cond:
+ // result: (SETGF (UCOMISD y x))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETGF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(y)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less64U x y)
+ // cond:
+ // result: (SETB (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETB)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less8 x y)
+ // cond:
+ // result: (SETL (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETL)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less8U x y)
+ // cond:
+ // result: (SETB (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETB)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Load <t> ptr mem)
+ // cond: (is64BitInt(t) || isPtr(t))
+ // result: (MOVQload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(is64BitInt(t) || isPtr(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVQload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: is32BitInt(t)
+ // result: (MOVLload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(is32BitInt(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVLload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: is16BitInt(t)
+ // result: (MOVWload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(is16BitInt(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVWload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: (t.IsBoolean() || is8BitInt(t))
+ // result: (MOVBload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsBoolean() || is8BitInt(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVBload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: is32BitFloat(t)
+ // result: (MOVSSload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(is32BitFloat(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: is64BitFloat(t)
+ // result: (MOVSDload ptr mem)
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(is64BitFloat(t)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDload)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lrot16 <t> x [c])
+ // cond:
+ // result: (ROLWconst <t> [c&15] x)
+ for {
+ t := v.Type
+ x := v.Args[0]
+ c := v.AuxInt
+ v.reset(OpAMD64ROLWconst)
+ v.Type = t
+ v.AuxInt = c & 15
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lrot32 <t> x [c])
+ // cond:
+ // result: (ROLLconst <t> [c&31] x)
+ for {
+ t := v.Type
+ x := v.Args[0]
+ c := v.AuxInt
+ v.reset(OpAMD64ROLLconst)
+ v.Type = t
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lrot64 <t> x [c])
+ // cond:
+ // result: (ROLQconst <t> [c&63] x)
+ for {
+ t := v.Type
+ x := v.Args[0]
+ c := v.AuxInt
+ v.reset(OpAMD64ROLQconst)
+ v.Type = t
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lrot8 <t> x [c])
+ // cond:
+ // result: (ROLBconst <t> [c&7] x)
+ for {
+ t := v.Type
+ x := v.Args[0]
+ c := v.AuxInt
+ v.reset(OpAMD64ROLBconst)
+ v.Type = t
+ v.AuxInt = c & 7
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x16 <t> x y)
+ // cond:
+ // result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x32 <t> x y)
+ // cond:
+ // result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x64 <t> x y)
+ // cond:
+ // result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x8 <t> x y)
+ // cond:
+ // result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x16 <t> x y)
+ // cond:
+ // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x32 <t> x y)
+ // cond:
+ // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x64 <t> x y)
+ // cond:
+ // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x8 <t> x y)
+ // cond:
+ // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x16 <t> x y)
+ // cond:
+ // result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x32 <t> x y)
+ // cond:
+ // result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x64 <t> x y)
+ // cond:
+ // result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x8 <t> x y)
+ // cond:
+ // result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x16 <t> x y)
+ // cond:
+ // result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x32 <t> x y)
+ // cond:
+ // result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x64 <t> x y)
+ // cond:
+ // result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x8 <t> x y)
+ // cond:
+ // result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHLB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBQSX (MOVBload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVBQSXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVBQSXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVBQSX (ANDBconst [c] x))
+ // cond: c & 0x80 == 0
+ // result: (ANDQconst [c & 0x7f] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if !(c&0x80 == 0) {
+ break
+ }
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0x7f
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBQZX (MOVBload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVBQZXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVBQZXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVBQZX (ANDBconst [c] x))
+ // cond:
+ // result: (ANDQconst [c & 0xff] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0xff
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
+ // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
+ // result: x
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBstore {
+ break
+ }
+ off2 := v.Args[1].AuxInt
+ sym2 := v.Args[1].Aux
+ ptr2 := v.Args[1].Args[0]
+ x := v.Args[1].Args[1]
+ if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVBload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVBload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVBload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBload [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVBloadidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ1 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVBloadidx1)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBload [off] {sym} (ADDQ ptr idx) mem)
+ // cond: ptr.Op != OpSB
+ // result: (MOVBloadidx1 [off] {sym} ptr idx mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQ {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(ptr.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64MOVBloadidx1)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBloadidx1)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBloadidx1 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBloadidx1)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
+ // cond:
+ // result: (MOVBstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBQSX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off] {sym} ptr (MOVBQZX x) mem)
+ // cond:
+ // result: (MOVBstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBQZX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVBstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem)
+ // cond: validOff(off)
+ // result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ mem := v.Args[2]
+ if !(validOff(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = makeValAndOff(int64(int8(c)), off)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVBstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVBstoreidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ1 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreidx1)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstore [off] {sym} (ADDQ ptr idx) val mem)
+ // cond: ptr.Op != OpSB
+ // result: (MOVBstoreidx1 [off] {sym} ptr idx val mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQ {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(ptr.Op != OpSB) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreidx1)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
+ // cond: ValAndOff(sc).canAdd(off)
+ // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+ for {
+ sc := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = s
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
+ // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
+ // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+ for {
+ sc := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstoreconst [x] {sym1} (LEAQ1 [off] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVBstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ1 {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVBstoreconstidx1)
+ v.AuxInt = ValAndOff(x).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstoreconst [x] {sym} (ADDQ ptr idx) mem)
+ // cond:
+ // result: (MOVBstoreconstidx1 [x] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQ {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVBstoreconstidx1)
+ v.AuxInt = x
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem)
+ // cond:
+ // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstoreconstidx1)
+ v.AuxInt = ValAndOff(x).add(c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstoreconstidx1 [x] {sym} ptr (ADDQconst [c] idx) mem)
+ // cond:
+ // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstoreconstidx1)
+ v.AuxInt = ValAndOff(x).add(c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVBstoreidx1)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVBstoreidx1 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVBstoreidx1)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLQSX (MOVLload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVLQSXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLQSXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVLQSX (ANDLconst [c] x))
+ // cond: c & 0x80000000 == 0
+ // result: (ANDQconst [c & 0x7fffffff] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if !(c&0x80000000 == 0) {
+ break
+ }
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0x7fffffff
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLQZX (MOVLload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVLQZXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLQZXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVLQZX (ANDLconst [c] x))
+ // cond:
+ // result: (ANDQconst [c & 0xffffffff] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0xffffffff
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
+ // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
+ // result: x
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLstore {
+ break
+ }
+ off2 := v.Args[1].AuxInt
+ sym2 := v.Args[1].Aux
+ ptr2 := v.Args[1].Args[0]
+ x := v.Args[1].Args[1]
+ if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVLload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVLload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVLload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVLloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVLloadidx4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLloadidx4)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVLloadidx4 [c+4*d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLloadidx4)
+ v.AuxInt = c + 4*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
+ // cond:
+ // result: (MOVLstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLQSX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstore [off] {sym} ptr (MOVLQZX x) mem)
+ // cond:
+ // result: (MOVLstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLQZX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVLstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem)
+ // cond: validOff(off)
+ // result: (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ mem := v.Args[2]
+ if !(validOff(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstoreconst)
+ v.AuxInt = makeValAndOff(int64(int32(c)), off)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVLstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVLstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstoreidx4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
+ // cond: ValAndOff(sc).canAdd(off)
+ // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+ for {
+ sc := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = s
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
+ // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
+ // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+ for {
+ sc := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstoreconst [x] {sym1} (LEAQ4 [off] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVLstoreconstidx4 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVLstoreconstidx4)
+ v.AuxInt = ValAndOff(x).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem)
+ // cond:
+ // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstoreconstidx4)
+ v.AuxInt = ValAndOff(x).add(c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstoreconstidx4 [x] {sym} ptr (ADDQconst [c] idx) mem)
+ // cond:
+ // result: (MOVLstoreconstidx4 [ValAndOff(x).add(4*c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstoreconstidx4)
+ v.AuxInt = ValAndOff(x).add(4 * c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVLstoreidx4)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVLstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVLstoreidx4 [c+4*d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVLstoreidx4)
+ v.AuxInt = c + 4*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVOload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVOload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVOload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVOstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVOstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVOstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVOstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVOstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _))
+ // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
+ // result: x
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQstore {
+ break
+ }
+ off2 := v.Args[1].AuxInt
+ sym2 := v.Args[1].Aux
+ ptr2 := v.Args[1].Args[0]
+ x := v.Args[1].Args[1]
+ if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVQload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVQload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVQloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVQloadidx8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVQloadidx8 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQloadidx8)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVQloadidx8 [c+8*d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQloadidx8)
+ v.AuxInt = c + 8*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVQstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem)
+ // cond: validValAndOff(c,off)
+ // result: (MOVQstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ mem := v.Args[2]
+ if !(validValAndOff(c, off)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = makeValAndOff(c, off)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVQstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstoreidx8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
+ // cond: ValAndOff(sc).canAdd(off)
+ // result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+ for {
+ sc := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = s
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
+ // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
+ // result: (MOVQstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+ for {
+ sc := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstoreconst [x] {sym1} (LEAQ8 [off] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVQstoreconstidx8 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVQstoreconstidx8)
+ v.AuxInt = ValAndOff(x).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem)
+ // cond:
+ // result: (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQstoreconstidx8)
+ v.AuxInt = ValAndOff(x).add(c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstoreconstidx8 [x] {sym} ptr (ADDQconst [c] idx) mem)
+ // cond:
+ // result: (MOVQstoreconstidx8 [ValAndOff(x).add(8*c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQstoreconstidx8)
+ v.AuxInt = ValAndOff(x).add(8 * c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVQstoreidx8)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVQstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVQstoreidx8 [c+8*d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVQstoreidx8)
+ v.AuxInt = c + 8*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVSDload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVSDload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSDloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDloadidx8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSDloadidx8)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVSDloadidx8 [c+8*d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSDloadidx8)
+ v.AuxInt = c + 8*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVSDstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSDstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ8 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDstoreidx8)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVSDstoreidx8)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSDstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVSDstoreidx8 [c+8*d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVSDstoreidx8)
+ v.AuxInt = c + 8*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVSSload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVSSload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSSloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSloadidx4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSSloadidx4)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVSSloadidx4 [c+4*d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSSloadidx4)
+ v.AuxInt = c + 4*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVSSstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVSSstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVSSstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ4 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSstoreidx4)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVSSstoreidx4)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVSSstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVSSstoreidx4 [c+4*d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVSSstoreidx4)
+ v.AuxInt = c + 4*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWQSX (MOVWload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVWQSXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVWQSXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVWQSX (ANDWconst [c] x))
+ // cond: c & 0x8000 == 0
+ // result: (ANDQconst [c & 0x7fff] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ if !(c&0x8000 == 0) {
+ break
+ }
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0x7fff
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWQZX (MOVWload [off] {sym} ptr mem))
+ // cond:
+ // result: @v.Args[0].Block (MOVWQZXload <v.Type> [off] {sym} ptr mem)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWload {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpAMD64MOVWQZXload, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v0.AuxInt = off
+ v0.Aux = sym
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ return true
+ }
+ // match: (MOVWQZX (ANDWconst [c] x))
+ // cond:
+ // result: (ANDQconst [c & 0xffff] x)
+ for {
+ if v.Args[0].Op != OpAMD64ANDWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ANDQconst)
+ v.AuxInt = c & 0xffff
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
+ // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
+ // result: x
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWstore {
+ break
+ }
+ off2 := v.Args[1].AuxInt
+ sym2 := v.Args[1].Aux
+ ptr2 := v.Args[1].Args[0]
+ x := v.Args[1].Args[1]
+ if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem)
+ // cond:
+ // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVWload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVWload)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWload [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVWloadidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ2 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVWloadidx2)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem)
+ // cond:
+ // result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWloadidx2)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWloadidx2 [c] {sym} ptr (ADDQconst [d] idx) mem)
+ // cond:
+ // result: (MOVWloadidx2 [c+2*d] {sym} ptr idx mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWloadidx2)
+ v.AuxInt = c + 2*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
+ // cond:
+ // result: (MOVWstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWQSX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstore [off] {sym} ptr (MOVWQZX x) mem)
+ // cond:
+ // result: (MOVWstore [off] {sym} ptr x mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWQZX {
+ break
+ }
+ x := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AuxInt = off
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(x)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
+ // cond:
+ // result: (MOVWstore [addOff(off1, off2)] {sym} ptr val mem)
+ for {
+ off1 := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem)
+ // cond: validOff(off)
+ // result: (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
+ for {
+ off := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ mem := v.Args[2]
+ if !(validOff(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstoreconst)
+ v.AuxInt = makeValAndOff(int64(int16(c)), off)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVWstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ base := v.Args[0].Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstore)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(base)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstore [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) val mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVWstoreidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
+ for {
+ off1 := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ2 {
+ break
+ }
+ off2 := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstoreidx2)
+ v.AuxInt = addOff(off1, off2)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
+ // cond: ValAndOff(sc).canAdd(off)
+ // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
+ for {
+ sc := v.AuxInt
+ s := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ off := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = s
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
+ // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
+ // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
+ for {
+ sc := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstoreconst)
+ v.AuxInt = ValAndOff(sc).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstoreconst [x] {sym1} (LEAQ2 [off] {sym2} ptr idx) mem)
+ // cond: canMergeSym(sym1, sym2)
+ // result: (MOVWstoreconstidx2 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym1 := v.Aux
+ if v.Args[0].Op != OpAMD64LEAQ2 {
+ break
+ }
+ off := v.Args[0].AuxInt
+ sym2 := v.Args[0].Aux
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[0].Args[1]
+ mem := v.Args[1]
+ if !(canMergeSym(sym1, sym2)) {
+ break
+ }
+ v.reset(OpAMD64MOVWstoreconstidx2)
+ v.AuxInt = ValAndOff(x).add(off)
+ v.Aux = mergeSym(sym1, sym2)
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem)
+ // cond:
+ // result: (MOVWstoreconstidx2 [ValAndOff(x).add(c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstoreconstidx2)
+ v.AuxInt = ValAndOff(x).add(c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstoreconstidx2 [x] {sym} ptr (ADDQconst [c] idx) mem)
+ // cond:
+ // result: (MOVWstoreconstidx2 [ValAndOff(x).add(2*c)] {sym} ptr idx mem)
+ for {
+ x := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstoreconstidx2)
+ v.AuxInt = ValAndOff(x).add(2 * c)
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem)
+ // cond:
+ // result: (MOVWstoreidx2 [c+d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ if v.Args[0].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ ptr := v.Args[0].Args[0]
+ idx := v.Args[1]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVWstoreidx2)
+ v.AuxInt = c + d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (MOVWstoreidx2 [c] {sym} ptr (ADDQconst [d] idx) val mem)
+ // cond:
+ // result: (MOVWstoreidx2 [c+2*d] {sym} ptr idx val mem)
+ for {
+ c := v.AuxInt
+ sym := v.Aux
+ ptr := v.Args[0]
+ if v.Args[1].Op != OpAMD64ADDQconst {
+ break
+ }
+ d := v.Args[1].AuxInt
+ idx := v.Args[1].Args[0]
+ val := v.Args[2]
+ mem := v.Args[3]
+ v.reset(OpAMD64MOVWstoreidx2)
+ v.AuxInt = c + 2*d
+ v.Aux = sym
+ v.AddArg(ptr)
+ v.AddArg(idx)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULB x (MOVBconst [c]))
+ // cond:
+ // result: (MULBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64MULBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULB (MOVBconst [c]) x)
+ // cond:
+ // result: (MULBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64MULBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [c*d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = c * d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULL x (MOVLconst [c]))
+ // cond:
+ // result: (MULLconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64MULLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULL (MOVLconst [c]) x)
+ // cond:
+ // result: (MULLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64MULLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [c*d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = c * d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (MULQconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64MULQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (MULQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64MULQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULQconst [-1] x)
+ // cond:
+ // result: (NEGQ x)
+ for {
+ if v.AuxInt != -1 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpAMD64NEGQ)
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [0] _)
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (MULQconst [1] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [3] x)
+ // cond:
+ // result: (LEAQ2 x x)
+ for {
+ if v.AuxInt != 3 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpAMD64LEAQ2)
+ v.AddArg(x)
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [5] x)
+ // cond:
+ // result: (LEAQ4 x x)
+ for {
+ if v.AuxInt != 5 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpAMD64LEAQ4)
+ v.AddArg(x)
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [9] x)
+ // cond:
+ // result: (LEAQ8 x x)
+ for {
+ if v.AuxInt != 9 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpAMD64LEAQ8)
+ v.AddArg(x)
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [c] x)
+ // cond: isPowerOfTwo(c)
+ // result: (SHLQconst [log2(c)] x)
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(isPowerOfTwo(c)) {
+ break
+ }
+ v.reset(OpAMD64SHLQconst)
+ v.AuxInt = log2(c)
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [c*d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = c * d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULW x (MOVWconst [c]))
+ // cond:
+ // result: (MULWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64MULWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (MULW (MOVWconst [c]) x)
+ // cond:
+ // result: (MULWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64MULWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (MULWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [c*d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = c * d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod16 x y)
+ // cond:
+ // result: (MODW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod16u x y)
+ // cond:
+ // result: (MODWU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODWU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod32 x y)
+ // cond:
+ // result: (MODL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod32u x y)
+ // cond:
+ // result: (MODLU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODLU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod64 x y)
+ // cond:
+ // result: (MODQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod64u x y)
+ // cond:
+ // result: (MODQU x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODQU)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod8 x y)
+ // cond:
+ // result: (MODW (SignExt8to16 x) (SignExt8to16 y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODW)
+ v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod8u x y)
+ // cond:
+ // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MODWU)
+ v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMove(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Move [0] _ _ mem)
+ // cond:
+ // result: mem
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ mem := v.Args[2]
+ v.reset(OpCopy)
+ v.Type = mem.Type
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [1] dst src mem)
+ // cond:
+ // result: (MOVBstore dst (MOVBload src mem) mem)
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8())
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [2] dst src mem)
+ // cond:
+ // result: (MOVWstore dst (MOVWload src mem) mem)
+ for {
+ if v.AuxInt != 2 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16())
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [4] dst src mem)
+ // cond:
+ // result: (MOVLstore dst (MOVLload src mem) mem)
+ for {
+ if v.AuxInt != 4 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32())
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [8] dst src mem)
+ // cond:
+ // result: (MOVQstore dst (MOVQload src mem) mem)
+ for {
+ if v.AuxInt != 8 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQstore)
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64())
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [16] dst src mem)
+ // cond:
+ // result: (MOVOstore dst (MOVOload src mem) mem)
+ for {
+ if v.AuxInt != 16 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVOstore)
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInt128)
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [3] dst src mem)
+ // cond:
+ // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem))
+ for {
+ if v.AuxInt != 3 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = 2
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8())
+ v0.AuxInt = 2
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeMem)
+ v1.AddArg(dst)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16())
+ v2.AddArg(src)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Move [5] dst src mem)
+ // cond:
+ // result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
+ for {
+ if v.AuxInt != 5 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AuxInt = 4
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8())
+ v0.AuxInt = 4
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem)
+ v1.AddArg(dst)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32())
+ v2.AddArg(src)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Move [6] dst src mem)
+ // cond:
+ // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
+ for {
+ if v.AuxInt != 6 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AuxInt = 4
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16())
+ v0.AuxInt = 4
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem)
+ v1.AddArg(dst)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32())
+ v2.AddArg(src)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Move [7] dst src mem)
+ // cond:
+ // result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem))
+ for {
+ if v.AuxInt != 7 {
+ break
+ }
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AuxInt = 3
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32())
+ v0.AuxInt = 3
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem)
+ v1.AddArg(dst)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32())
+ v2.AddArg(src)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Move [size] dst src mem)
+ // cond: size > 8 && size < 16
+ // result: (MOVQstore [size-8] dst (MOVQload [size-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ if !(size > 8 && size < 16) {
+ break
+ }
+ v.reset(OpAMD64MOVQstore)
+ v.AuxInt = size - 8
+ v.AddArg(dst)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64())
+ v0.AuxInt = size - 8
+ v0.AddArg(src)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem)
+ v1.AddArg(dst)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64())
+ v2.AddArg(src)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Move [size] dst src mem)
+ // cond: size > 16 && size%16 != 0 && size%16 <= 8
+ // result: (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16]) (MOVQstore dst (MOVQload src mem) mem))
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ if !(size > 16 && size%16 != 0 && size%16 <= 8) {
+ break
+ }
+ v.reset(OpMove)
+ v.AuxInt = size - size%16
+ v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type)
+ v0.AddArg(dst)
+ v0.AuxInt = size % 16
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, src.Type)
+ v1.AddArg(src)
+ v1.AuxInt = size % 16
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem)
+ v2.AddArg(dst)
+ v3 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64())
+ v3.AddArg(src)
+ v3.AddArg(mem)
+ v2.AddArg(v3)
+ v2.AddArg(mem)
+ v.AddArg(v2)
+ return true
+ }
+ // match: (Move [size] dst src mem)
+ // cond: size > 16 && size%16 != 0 && size%16 > 8
+ // result: (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16]) (MOVOstore dst (MOVOload src mem) mem))
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ if !(size > 16 && size%16 != 0 && size%16 > 8) {
+ break
+ }
+ v.reset(OpMove)
+ v.AuxInt = size - size%16
+ v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type)
+ v0.AddArg(dst)
+ v0.AuxInt = size % 16
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, src.Type)
+ v1.AddArg(src)
+ v1.AuxInt = size % 16
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeMem)
+ v2.AddArg(dst)
+ v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInt128)
+ v3.AddArg(src)
+ v3.AddArg(mem)
+ v2.AddArg(v3)
+ v2.AddArg(mem)
+ v.AddArg(v2)
+ return true
+ }
+ // match: (Move [size] dst src mem)
+ // cond: size >= 32 && size <= 16*64 && size%16 == 0
+ // result: (DUFFCOPY [14*(64-size/16)] dst src mem)
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ if !(size >= 32 && size <= 16*64 && size%16 == 0) {
+ break
+ }
+ v.reset(OpAMD64DUFFCOPY)
+ v.AuxInt = 14 * (64 - size/16)
+ v.AddArg(dst)
+ v.AddArg(src)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Move [size] dst src mem)
+ // cond: size > 16*64 && size%8 == 0
+ // result: (REPMOVSQ dst src (MOVQconst [size/8]) mem)
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ src := v.Args[1]
+ mem := v.Args[2]
+ if !(size > 16*64 && size%8 == 0) {
+ break
+ }
+ v.reset(OpAMD64REPMOVSQ)
+ v.AddArg(dst)
+ v.AddArg(src)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64())
+ v0.AuxInt = size / 8
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul16 x y)
+ // cond:
+ // result: (MULW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul32 x y)
+ // cond:
+ // result: (MULL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul32F x y)
+ // cond:
+ // result: (MULSS x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULSS)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul64 x y)
+ // cond:
+ // result: (MULQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul64F x y)
+ // cond:
+ // result: (MULSD x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULSD)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul8 x y)
+ // cond:
+ // result: (MULB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64MULB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NEGB (MOVBconst [c]))
+ // cond:
+ // result: (MOVBconst [-c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = -c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NEGL (MOVLconst [c]))
+ // cond:
+ // result: (MOVLconst [-c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = -c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NEGQ (MOVQconst [c]))
+ // cond:
+ // result: (MOVQconst [-c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = -c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NEGW (MOVWconst [c]))
+ // cond:
+ // result: (MOVWconst [-c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = -c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NOTB (MOVBconst [c]))
+ // cond:
+ // result: (MOVBconst [^c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = ^c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NOTL (MOVLconst [c]))
+ // cond:
+ // result: (MOVLconst [^c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = ^c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NOTQ (MOVQconst [c]))
+ // cond:
+ // result: (MOVQconst [^c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = ^c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NOTW (MOVWconst [c]))
+ // cond:
+ // result: (MOVWconst [^c])
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = ^c
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg16 x)
+ // cond:
+ // result: (NEGW x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NEGW)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg32 x)
+ // cond:
+ // result: (NEGL x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NEGL)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg32F x)
+ // cond:
+ // result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))]))
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64PXOR)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, config.Frontend().TypeFloat32())
+ v0.AuxInt = f2i(math.Copysign(0, -1))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg64 x)
+ // cond:
+ // result: (NEGQ x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NEGQ)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg64F x)
+ // cond:
+ // result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64PXOR)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, config.Frontend().TypeFloat64())
+ v0.AuxInt = f2i(math.Copysign(0, -1))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg8 x)
+ // cond:
+ // result: (NEGB x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64NEGB)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq16 x y)
+ // cond:
+ // result: (SETNE (CMPW x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq32 x y)
+ // cond:
+ // result: (SETNE (CMPL x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq32F x y)
+ // cond:
+ // result: (SETNEF (UCOMISS x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq64 x y)
+ // cond:
+ // result: (SETNE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq64F x y)
+ // cond:
+ // result: (SETNEF (UCOMISD x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNEF)
+ v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq8 x y)
+ // cond:
+ // result: (SETNE (CMPB x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NeqPtr x y)
+ // cond:
+ // result: (SETNE (CMPQ x y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SETNE)
+ v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NilCheck ptr mem)
+ // cond:
+ // result: (LoweredNilCheck ptr mem)
+ for {
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64LoweredNilCheck)
+ v.AddArg(ptr)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpNot(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Not x)
+ // cond:
+ // result: (XORBconst [1] x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64XORBconst)
+ v.AuxInt = 1
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORB x (MOVBconst [c]))
+ // cond:
+ // result: (ORBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ORBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORB (MOVBconst [c]) x)
+ // cond:
+ // result: (ORBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ORBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORB x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORBconst [c] x)
+ // cond: int8(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int8(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORBconst [c] _)
+ // cond: int8(c)==-1
+ // result: (MOVBconst [-1])
+ for {
+ c := v.AuxInt
+ if !(int8(c) == -1) {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (ORBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [c|d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = c | d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORL x (MOVLconst [c]))
+ // cond:
+ // result: (ORLconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ORLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORL (MOVLconst [c]) x)
+ // cond:
+ // result: (ORLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ORLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORL x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORLconst [c] x)
+ // cond: int32(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int32(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORLconst [c] _)
+ // cond: int32(c)==-1
+ // result: (MOVLconst [-1])
+ for {
+ c := v.AuxInt
+ if !(int32(c) == -1) {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (ORLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [c|d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = c | d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (ORQconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ORQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (ORQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64ORQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORQ x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORQconst [0] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORQconst [-1] _)
+ // cond:
+ // result: (MOVQconst [-1])
+ for {
+ if v.AuxInt != -1 {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (ORQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [c|d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = c | d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORW x (MOVWconst [c]))
+ // cond:
+ // result: (ORWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64ORWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORW (MOVWconst [c]) x)
+ // cond:
+ // result: (ORWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64ORWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORW x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ORWconst [c] x)
+ // cond: int16(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int16(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (ORWconst [c] _)
+ // cond: int16(c)==-1
+ // result: (MOVWconst [-1])
+ for {
+ c := v.AuxInt
+ if !(int16(c) == -1) {
+ break
+ }
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (ORWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [c|d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = c | d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (OffPtr [off] ptr)
+ // cond:
+ // result: (ADDQconst [off] ptr)
+ for {
+ off := v.AuxInt
+ ptr := v.Args[0]
+ v.reset(OpAMD64ADDQconst)
+ v.AuxInt = off
+ v.AddArg(ptr)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or16 x y)
+ // cond:
+ // result: (ORW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ORW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or32 x y)
+ // cond:
+ // result: (ORL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ORL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or64 x y)
+ // cond:
+ // result: (ORQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ORQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or8 x y)
+ // cond:
+ // result: (ORB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ORB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux16 <t> x y)
+ // cond:
+ // result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux32 <t> x y)
+ // cond:
+ // result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux64 <t> x y)
+ // cond:
+ // result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux8 <t> x y)
+ // cond:
+ // result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDW)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRW, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 16
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x16 <t> x y)
+ // cond:
+ // result: (SARW <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [16])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARW)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 16
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x32 <t> x y)
+ // cond:
+ // result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [16])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARW)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 16
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x64 <t> x y)
+ // cond:
+ // result: (SARW <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [16])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARW)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTQ, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 16
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x8 <t> x y)
+ // cond:
+ // result: (SARW <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [16])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARW)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 16
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux16 <t> x y)
+ // cond:
+ // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux32 <t> x y)
+ // cond:
+ // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux64 <t> x y)
+ // cond:
+ // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux8 <t> x y)
+ // cond:
+ // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDL)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRL, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 32
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x16 <t> x y)
+ // cond:
+ // result: (SARL <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [32])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARL)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 32
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x32 <t> x y)
+ // cond:
+ // result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [32])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARL)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 32
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x64 <t> x y)
+ // cond:
+ // result: (SARL <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [32])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARL)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTQ, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 32
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x8 <t> x y)
+ // cond:
+ // result: (SARL <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [32])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARL)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 32
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux16 <t> x y)
+ // cond:
+ // result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux32 <t> x y)
+ // cond:
+ // result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux64 <t> x y)
+ // cond:
+ // result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux8 <t> x y)
+ // cond:
+ // result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 64
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x16 <t> x y)
+ // cond:
+ // result: (SARQ <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [64])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARQ)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 64
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x32 <t> x y)
+ // cond:
+ // result: (SARQ <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [64])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARQ)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 64
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x64 <t> x y)
+ // cond:
+ // result: (SARQ <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [64])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARQ)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTQ, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 64
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x8 <t> x y)
+ // cond:
+ // result: (SARQ <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [64])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARQ)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 64
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux16 <t> x y)
+ // cond:
+ // result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux32 <t> x y)
+ // cond:
+ // result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux64 <t> x y)
+ // cond:
+ // result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux8 <t> x y)
+ // cond:
+ // result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64ANDB)
+ v0 := b.NewValue0(v.Line, OpAMD64SHRB, t)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t)
+ v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v2.AddArg(y)
+ v2.AuxInt = 8
+ v1.AddArg(v2)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x16 <t> x y)
+ // cond:
+ // result: (SARB <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [8])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARB)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 8
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x32 <t> x y)
+ // cond:
+ // result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [8])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARB)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 8
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x64 <t> x y)
+ // cond:
+ // result: (SARB <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [8])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARB)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTQ, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 8
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x8 <t> x y)
+ // cond:
+ // result: (SARB <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [8])))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SARB)
+ v.Type = t
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type)
+ v0.AddArg(y)
+ v1 := b.NewValue0(v.Line, OpAMD64NOTL, y.Type)
+ v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, y.Type)
+ v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags)
+ v3.AddArg(y)
+ v3.AuxInt = 8
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARB x (MOVQconst [c]))
+ // cond:
+ // result: (SARBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARB x (MOVLconst [c]))
+ // cond:
+ // result: (SARBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARB x (MOVWconst [c]))
+ // cond:
+ // result: (SARBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARB x (MOVBconst [c]))
+ // cond:
+ // result: (SARBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARBconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [d>>uint64(c)])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = d >> uint64(c)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARL x (MOVQconst [c]))
+ // cond:
+ // result: (SARLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARL x (MOVLconst [c]))
+ // cond:
+ // result: (SARLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARL x (MOVWconst [c]))
+ // cond:
+ // result: (SARLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARL x (MOVBconst [c]))
+ // cond:
+ // result: (SARLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARLconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [d>>uint64(c)])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = d >> uint64(c)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARQ x (MOVQconst [c]))
+ // cond:
+ // result: (SARQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARQ x (MOVLconst [c]))
+ // cond:
+ // result: (SARQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARQ x (MOVWconst [c]))
+ // cond:
+ // result: (SARQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARQ x (MOVBconst [c]))
+ // cond:
+ // result: (SARQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [d>>uint64(c)])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = d >> uint64(c)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARW x (MOVQconst [c]))
+ // cond:
+ // result: (SARWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARW x (MOVLconst [c]))
+ // cond:
+ // result: (SARWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARW x (MOVWconst [c]))
+ // cond:
+ // result: (SARWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SARW x (MOVBconst [c]))
+ // cond:
+ // result: (SARWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SARWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SARWconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [d>>uint64(c)])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = d >> uint64(c)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SBBLcarrymask (FlagEQ))
+ // cond:
+ // result: (MOVLconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SBBLcarrymask (FlagLT_ULT))
+ // cond:
+ // result: (MOVLconst [-1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (SBBLcarrymask (FlagLT_UGT))
+ // cond:
+ // result: (MOVLconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SBBLcarrymask (FlagGT_ULT))
+ // cond:
+ // result: (MOVLconst [-1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (SBBLcarrymask (FlagGT_UGT))
+ // cond:
+ // result: (MOVLconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SBBQcarrymask (FlagEQ))
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SBBQcarrymask (FlagLT_ULT))
+ // cond:
+ // result: (MOVQconst [-1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (SBBQcarrymask (FlagLT_UGT))
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SBBQcarrymask (FlagGT_ULT))
+ // cond:
+ // result: (MOVQconst [-1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = -1
+ return true
+ }
+ // match: (SBBQcarrymask (FlagGT_UGT))
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETA (InvertFlags x))
+ // cond:
+ // result: (SETB x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETB)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETA (FlagEQ))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETA (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETA (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETA (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETA (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETAE (InvertFlags x))
+ // cond:
+ // result: (SETBE x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETBE)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETAE (FlagEQ))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETAE (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETAE (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETAE (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETAE (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETB (InvertFlags x))
+ // cond:
+ // result: (SETA x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETA)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETB (FlagEQ))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETB (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETB (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETB (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETB (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETBE (InvertFlags x))
+ // cond:
+ // result: (SETAE x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETAE)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETBE (FlagEQ))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETBE (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETBE (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETBE (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETBE (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETEQ (InvertFlags x))
+ // cond:
+ // result: (SETEQ x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETEQ)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETEQ (FlagEQ))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETEQ (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETEQ (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETEQ (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETEQ (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETG (InvertFlags x))
+ // cond:
+ // result: (SETL x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETL)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETG (FlagEQ))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETG (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETG (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETG (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETG (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETGE (InvertFlags x))
+ // cond:
+ // result: (SETLE x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETLE)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETGE (FlagEQ))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETGE (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETGE (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETGE (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETGE (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETL (InvertFlags x))
+ // cond:
+ // result: (SETG x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETG)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETL (FlagEQ))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETL (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETL (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETL (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETL (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETLE (InvertFlags x))
+ // cond:
+ // result: (SETGE x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETGE)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETLE (FlagEQ))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETLE (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETLE (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETLE (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETLE (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SETNE (InvertFlags x))
+ // cond:
+ // result: (SETNE x)
+ for {
+ if v.Args[0].Op != OpAMD64InvertFlags {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64SETNE)
+ v.AddArg(x)
+ return true
+ }
+ // match: (SETNE (FlagEQ))
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ if v.Args[0].Op != OpAMD64FlagEQ {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (SETNE (FlagLT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETNE (FlagLT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETNE (FlagGT_ULT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (SETNE (FlagGT_UGT))
+ // cond:
+ // result: (MOVBconst [1])
+ for {
+ if v.Args[0].Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 1
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHLB x (MOVQconst [c]))
+ // cond:
+ // result: (SHLBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLB x (MOVLconst [c]))
+ // cond:
+ // result: (SHLBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLB x (MOVWconst [c]))
+ // cond:
+ // result: (SHLBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLB x (MOVBconst [c]))
+ // cond:
+ // result: (SHLBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHLL x (MOVQconst [c]))
+ // cond:
+ // result: (SHLLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLL x (MOVLconst [c]))
+ // cond:
+ // result: (SHLLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLL x (MOVWconst [c]))
+ // cond:
+ // result: (SHLLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLL x (MOVBconst [c]))
+ // cond:
+ // result: (SHLLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHLQ x (MOVQconst [c]))
+ // cond:
+ // result: (SHLQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLQ x (MOVLconst [c]))
+ // cond:
+ // result: (SHLQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLQ x (MOVWconst [c]))
+ // cond:
+ // result: (SHLQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLQ x (MOVBconst [c]))
+ // cond:
+ // result: (SHLQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHLW x (MOVQconst [c]))
+ // cond:
+ // result: (SHLWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLW x (MOVLconst [c]))
+ // cond:
+ // result: (SHLWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLW x (MOVWconst [c]))
+ // cond:
+ // result: (SHLWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHLW x (MOVBconst [c]))
+ // cond:
+ // result: (SHLWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHLWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHRB x (MOVQconst [c]))
+ // cond:
+ // result: (SHRBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRB x (MOVLconst [c]))
+ // cond:
+ // result: (SHRBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRB x (MOVWconst [c]))
+ // cond:
+ // result: (SHRBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRB x (MOVBconst [c]))
+ // cond:
+ // result: (SHRBconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRBconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHRL x (MOVQconst [c]))
+ // cond:
+ // result: (SHRLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRL x (MOVLconst [c]))
+ // cond:
+ // result: (SHRLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRL x (MOVWconst [c]))
+ // cond:
+ // result: (SHRLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRL x (MOVBconst [c]))
+ // cond:
+ // result: (SHRLconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRLconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHRQ x (MOVQconst [c]))
+ // cond:
+ // result: (SHRQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRQ x (MOVLconst [c]))
+ // cond:
+ // result: (SHRQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRQ x (MOVWconst [c]))
+ // cond:
+ // result: (SHRQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRQ x (MOVBconst [c]))
+ // cond:
+ // result: (SHRQconst [c&63] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRQconst)
+ v.AuxInt = c & 63
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SHRW x (MOVQconst [c]))
+ // cond:
+ // result: (SHRWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRW x (MOVLconst [c]))
+ // cond:
+ // result: (SHRWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRW x (MOVWconst [c]))
+ // cond:
+ // result: (SHRWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ // match: (SHRW x (MOVBconst [c]))
+ // cond:
+ // result: (SHRWconst [c&31] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SHRWconst)
+ v.AuxInt = c & 31
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBB x (MOVBconst [c]))
+ // cond:
+ // result: (SUBBconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SUBBconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (SUBB (MOVBconst [c]) x)
+ // cond:
+ // result: (NEGB (SUBBconst <v.Type> x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64NEGB)
+ v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, v.Type)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ // match: (SUBB x x)
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBBconst [c] x)
+ // cond: int8(c) == 0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int8(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (SUBBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [d-c])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = d - c
+ return true
+ }
+ // match: (SUBBconst [c] (SUBBconst [d] x))
+ // cond:
+ // result: (ADDBconst [-c-d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64SUBBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDBconst)
+ v.AuxInt = -c - d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBL x (MOVLconst [c]))
+ // cond:
+ // result: (SUBLconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SUBLconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (SUBL (MOVLconst [c]) x)
+ // cond:
+ // result: (NEGL (SUBLconst <v.Type> x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64NEGL)
+ v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, v.Type)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ // match: (SUBL x x)
+ // cond:
+ // result: (MOVLconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBLconst [c] x)
+ // cond: int32(c) == 0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int32(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (SUBLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [d-c])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = d - c
+ return true
+ }
+ // match: (SUBLconst [c] (SUBLconst [d] x))
+ // cond:
+ // result: (ADDLconst [-c-d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64SUBLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDLconst)
+ v.AuxInt = -c - d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (SUBQconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64SUBQconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (SUBQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (NEGQ (SUBQconst <v.Type> x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64NEGQ)
+ v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, v.Type)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ // match: (SUBQ x x)
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBQconst [0] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (SUBQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [d-c])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = d - c
+ return true
+ }
+ // match: (SUBQconst [c] (SUBQconst [d] x))
+ // cond:
+ // result: (ADDQconst [-c-d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64SUBQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDQconst)
+ v.AuxInt = -c - d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBW x (MOVWconst [c]))
+ // cond:
+ // result: (SUBWconst x [c])
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64SUBWconst)
+ v.AddArg(x)
+ v.AuxInt = c
+ return true
+ }
+ // match: (SUBW (MOVWconst [c]) x)
+ // cond:
+ // result: (NEGW (SUBWconst <v.Type> x [c]))
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64NEGW)
+ v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, v.Type)
+ v0.AddArg(x)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ return true
+ }
+ // match: (SUBW x x)
+ // cond:
+ // result: (MOVWconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SUBWconst [c] x)
+ // cond: int16(c) == 0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int16(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (SUBWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [d-c])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = d - c
+ return true
+ }
+ // match: (SUBWconst [c] (SUBWconst [d] x))
+ // cond:
+ // result: (ADDWconst [-c-d] x)
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64SUBWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ x := v.Args[0].Args[0]
+ v.reset(OpAMD64ADDWconst)
+ v.AuxInt = -c - d
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt16to32 x)
+ // cond:
+ // result: (MOVWQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVWQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt16to64 x)
+ // cond:
+ // result: (MOVWQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVWQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt32to64 x)
+ // cond:
+ // result: (MOVLQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVLQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt8to16 x)
+ // cond:
+ // result: (MOVBQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt8to32 x)
+ // cond:
+ // result: (MOVBQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SignExt8to64 x)
+ // cond:
+ // result: (MOVBQSX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQSX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sqrt x)
+ // cond:
+ // result: (SQRTSD x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64SQRTSD)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (StaticCall [argwid] {target} mem)
+ // cond:
+ // result: (CALLstatic [argwid] {target} mem)
+ for {
+ argwid := v.AuxInt
+ target := v.Aux
+ mem := v.Args[0]
+ v.reset(OpAMD64CALLstatic)
+ v.AuxInt = argwid
+ v.Aux = target
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpStore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Store [8] ptr val mem)
+ // cond: is64BitFloat(val.Type)
+ // result: (MOVSDstore ptr val mem)
+ for {
+ if v.AuxInt != 8 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(is64BitFloat(val.Type)) {
+ break
+ }
+ v.reset(OpAMD64MOVSDstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [4] ptr val mem)
+ // cond: is32BitFloat(val.Type)
+ // result: (MOVSSstore ptr val mem)
+ for {
+ if v.AuxInt != 4 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ if !(is32BitFloat(val.Type)) {
+ break
+ }
+ v.reset(OpAMD64MOVSSstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [8] ptr val mem)
+ // cond:
+ // result: (MOVQstore ptr val mem)
+ for {
+ if v.AuxInt != 8 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVQstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [4] ptr val mem)
+ // cond:
+ // result: (MOVLstore ptr val mem)
+ for {
+ if v.AuxInt != 4 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVLstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [2] ptr val mem)
+ // cond:
+ // result: (MOVWstore ptr val mem)
+ for {
+ if v.AuxInt != 2 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVWstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [1] ptr val mem)
+ // cond:
+ // result: (MOVBstore ptr val mem)
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ ptr := v.Args[0]
+ val := v.Args[1]
+ mem := v.Args[2]
+ v.reset(OpAMD64MOVBstore)
+ v.AddArg(ptr)
+ v.AddArg(val)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub16 x y)
+ // cond:
+ // result: (SUBW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub32 x y)
+ // cond:
+ // result: (SUBL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub32F x y)
+ // cond:
+ // result: (SUBSS x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBSS)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub64 x y)
+ // cond:
+ // result: (SUBQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub64F x y)
+ // cond:
+ // result: (SUBSD x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBSD)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub8 x y)
+ // cond:
+ // result: (SUBB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SubPtr x y)
+ // cond:
+ // result: (SUBQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64SUBQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc16to8 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc32to16 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc32to8 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to16 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to32 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to8 x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORB x (MOVBconst [c]))
+ // cond:
+ // result: (XORBconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64XORBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORB (MOVBconst [c]) x)
+ // cond:
+ // result: (XORBconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64XORBconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORB x x)
+ // cond:
+ // result: (MOVBconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORBconst [c] x)
+ // cond: int8(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int8(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORBconst [c] (MOVBconst [d]))
+ // cond:
+ // result: (MOVBconst [c^d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVBconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVBconst)
+ v.AuxInt = c ^ d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORL x (MOVLconst [c]))
+ // cond:
+ // result: (XORLconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64XORLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORL (MOVLconst [c]) x)
+ // cond:
+ // result: (XORLconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64XORLconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORL x x)
+ // cond:
+ // result: (MOVLconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORLconst [c] x)
+ // cond: int32(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int32(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORLconst [c] (MOVLconst [d]))
+ // cond:
+ // result: (MOVLconst [c^d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVLconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVLconst)
+ v.AuxInt = c ^ d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORQ x (MOVQconst [c]))
+ // cond: is32Bit(c)
+ // result: (XORQconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64XORQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORQ (MOVQconst [c]) x)
+ // cond: is32Bit(c)
+ // result: (XORQconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(is32Bit(c)) {
+ break
+ }
+ v.reset(OpAMD64XORQconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORQ x x)
+ // cond:
+ // result: (MOVQconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORQconst [0] x)
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ x := v.Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORQconst [c] (MOVQconst [d]))
+ // cond:
+ // result: (MOVQconst [c^d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVQconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVQconst)
+ v.AuxInt = c ^ d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORW x (MOVWconst [c]))
+ // cond:
+ // result: (XORWconst [c] x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpAMD64XORWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORW (MOVWconst [c]) x)
+ // cond:
+ // result: (XORWconst [c] x)
+ for {
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ c := v.Args[0].AuxInt
+ x := v.Args[1]
+ v.reset(OpAMD64XORWconst)
+ v.AuxInt = c
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORW x x)
+ // cond:
+ // result: (MOVWconst [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (XORWconst [c] x)
+ // cond: int16(c)==0
+ // result: x
+ for {
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(int16(c) == 0) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (XORWconst [c] (MOVWconst [d]))
+ // cond:
+ // result: (MOVWconst [c^d])
+ for {
+ c := v.AuxInt
+ if v.Args[0].Op != OpAMD64MOVWconst {
+ break
+ }
+ d := v.Args[0].AuxInt
+ v.reset(OpAMD64MOVWconst)
+ v.AuxInt = c ^ d
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor16 x y)
+ // cond:
+ // result: (XORW x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64XORW)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor32 x y)
+ // cond:
+ // result: (XORL x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64XORL)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor64 x y)
+ // cond:
+ // result: (XORQ x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64XORQ)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor8 x y)
+ // cond:
+ // result: (XORB x y)
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpAMD64XORB)
+ v.AddArg(x)
+ v.AddArg(y)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZero(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Zero [0] _ mem)
+ // cond:
+ // result: mem
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ mem := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = mem.Type
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [1] destptr mem)
+ // cond:
+ // result: (MOVBstoreconst [0] destptr mem)
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = 0
+ v.AddArg(destptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [2] destptr mem)
+ // cond:
+ // result: (MOVWstoreconst [0] destptr mem)
+ for {
+ if v.AuxInt != 2 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVWstoreconst)
+ v.AuxInt = 0
+ v.AddArg(destptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [4] destptr mem)
+ // cond:
+ // result: (MOVLstoreconst [0] destptr mem)
+ for {
+ if v.AuxInt != 4 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVLstoreconst)
+ v.AuxInt = 0
+ v.AddArg(destptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [8] destptr mem)
+ // cond:
+ // result: (MOVQstoreconst [0] destptr mem)
+ for {
+ if v.AuxInt != 8 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = 0
+ v.AddArg(destptr)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [3] destptr mem)
+ // cond:
+ // result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem))
+ for {
+ if v.AuxInt != 3 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = makeValAndOff(0, 2)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeMem)
+ v0.AuxInt = 0
+ v0.AddArg(destptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [5] destptr mem)
+ // cond:
+ // result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
+ for {
+ if v.AuxInt != 5 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVBstoreconst)
+ v.AuxInt = makeValAndOff(0, 4)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem)
+ v0.AuxInt = 0
+ v0.AddArg(destptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [6] destptr mem)
+ // cond:
+ // result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
+ for {
+ if v.AuxInt != 6 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVWstoreconst)
+ v.AuxInt = makeValAndOff(0, 4)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem)
+ v0.AuxInt = 0
+ v0.AddArg(destptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [7] destptr mem)
+ // cond:
+ // result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem))
+ for {
+ if v.AuxInt != 7 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVLstoreconst)
+ v.AuxInt = makeValAndOff(0, 3)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem)
+ v0.AuxInt = 0
+ v0.AddArg(destptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [size] destptr mem)
+ // cond: size%8 != 0 && size > 8
+ // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstoreconst [0] destptr mem))
+ for {
+ size := v.AuxInt
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ if !(size%8 != 0 && size > 8) {
+ break
+ }
+ v.reset(OpZero)
+ v.AuxInt = size - size%8
+ v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64())
+ v0.AddArg(destptr)
+ v0.AuxInt = size % 8
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v1.AuxInt = 0
+ v1.AddArg(destptr)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Zero [16] destptr mem)
+ // cond:
+ // result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
+ for {
+ if v.AuxInt != 16 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = makeValAndOff(0, 8)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v0.AuxInt = 0
+ v0.AddArg(destptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [24] destptr mem)
+ // cond:
+ // result: (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)))
+ for {
+ if v.AuxInt != 24 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = makeValAndOff(0, 16)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v0.AuxInt = makeValAndOff(0, 8)
+ v0.AddArg(destptr)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v1.AuxInt = 0
+ v1.AddArg(destptr)
+ v1.AddArg(mem)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [32] destptr mem)
+ // cond:
+ // result: (MOVQstoreconst [makeValAndOff(0,24)] destptr (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))))
+ for {
+ if v.AuxInt != 32 {
+ break
+ }
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ v.reset(OpAMD64MOVQstoreconst)
+ v.AuxInt = makeValAndOff(0, 24)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v0.AuxInt = makeValAndOff(0, 16)
+ v0.AddArg(destptr)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v1.AuxInt = makeValAndOff(0, 8)
+ v1.AddArg(destptr)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem)
+ v2.AuxInt = 0
+ v2.AddArg(destptr)
+ v2.AddArg(mem)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Zero [size] destptr mem)
+ // cond: size <= 1024 && size%8 == 0 && size%16 != 0
+ // result: (Zero [size-8] (ADDQconst [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
+ for {
+ size := v.AuxInt
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ if !(size <= 1024 && size%8 == 0 && size%16 != 0) {
+ break
+ }
+ v.reset(OpZero)
+ v.AuxInt = size - 8
+ v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64())
+ v0.AuxInt = 8
+ v0.AddArg(destptr)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem)
+ v1.AddArg(destptr)
+ v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64())
+ v2.AuxInt = 0
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Zero [size] destptr mem)
+ // cond: size <= 1024 && size%16 == 0
+ // result: (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVOconst [0]) mem)
+ for {
+ size := v.AuxInt
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ if !(size <= 1024 && size%16 == 0) {
+ break
+ }
+ v.reset(OpAMD64DUFFZERO)
+ v.AuxInt = duffStart(size)
+ v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64())
+ v0.AuxInt = duffAdj(size)
+ v0.AddArg(destptr)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInt128)
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Zero [size] destptr mem)
+ // cond: size > 1024 && size%8 == 0
+ // result: (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem)
+ for {
+ size := v.AuxInt
+ destptr := v.Args[0]
+ mem := v.Args[1]
+ if !(size > 1024 && size%8 == 0) {
+ break
+ }
+ v.reset(OpAMD64REPSTOSQ)
+ v.AddArg(destptr)
+ v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64())
+ v0.AuxInt = size / 8
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64())
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt16to32 x)
+ // cond:
+ // result: (MOVWQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVWQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt16to64 x)
+ // cond:
+ // result: (MOVWQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVWQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt32to64 x)
+ // cond:
+ // result: (MOVLQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVLQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt8to16 x)
+ // cond:
+ // result: (MOVBQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt8to32 x)
+ // cond:
+ // result: (MOVBQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ZeroExt8to64 x)
+ // cond:
+ // result: (MOVBQZX x)
+ for {
+ x := v.Args[0]
+ v.reset(OpAMD64MOVBQZX)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteBlockAMD64(b *Block) bool {
+ switch b.Kind {
+ case BlockAMD64EQ:
+ // match: (EQ (InvertFlags cmp) yes no)
+ // cond:
+ // result: (EQ cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64EQ
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (EQ (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (EQ (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (EQ (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (EQ (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (EQ (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ case BlockAMD64GE:
+ // match: (GE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (LE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (GE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (GE (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (GE (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (GE (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (GE (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockAMD64GT:
+ // match: (GT (InvertFlags cmp) yes no)
+ // cond:
+ // result: (LT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (GT (FlagEQ) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (GT (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (GT (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (GT (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (GT (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockIf:
+ // match: (If (SETL cmp) yes no)
+ // cond:
+ // result: (LT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETL {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETLE cmp) yes no)
+ // cond:
+ // result: (LE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETLE {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETG cmp) yes no)
+ // cond:
+ // result: (GT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETG {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETGE cmp) yes no)
+ // cond:
+ // result: (GE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETGE {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETEQ cmp) yes no)
+ // cond:
+ // result: (EQ cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETEQ {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64EQ
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETNE cmp) yes no)
+ // cond:
+ // result: (NE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETNE {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETB cmp) yes no)
+ // cond:
+ // result: (ULT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETB {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETBE cmp) yes no)
+ // cond:
+ // result: (ULE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETBE {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETA cmp) yes no)
+ // cond:
+ // result: (UGT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETA {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETAE cmp) yes no)
+ // cond:
+ // result: (UGE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETAE {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETGF cmp) yes no)
+ // cond:
+ // result: (UGT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETGF {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETGEF cmp) yes no)
+ // cond:
+ // result: (UGE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETGEF {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETEQF cmp) yes no)
+ // cond:
+ // result: (EQF cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETEQF {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64EQF
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (SETNEF cmp) yes no)
+ // cond:
+ // result: (NEF cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64SETNEF {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NEF
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If cond yes no)
+ // cond:
+ // result: (NE (TESTB cond cond) yes no)
+ for {
+ v := b.Control
+ cond := v
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NE
+ v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeFlags)
+ v0.AddArg(cond)
+ v0.AddArg(cond)
+ b.Control = v0
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockAMD64LE:
+ // match: (LE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (GE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LE (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LE (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LE (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (LE (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ case BlockAMD64LT:
+ // match: (LT (InvertFlags cmp) yes no)
+ // cond:
+ // result: (GT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LT (FlagEQ) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (LT (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LT (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (LT (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (LT (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ case BlockAMD64NE:
+ // match: (NE (TESTB (SETL cmp)) yes no)
+ // cond:
+ // result: (LT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETL {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETLE cmp)) yes no)
+ // cond:
+ // result: (LE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETLE {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64LE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETG cmp)) yes no)
+ // cond:
+ // result: (GT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETG {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETGE cmp)) yes no)
+ // cond:
+ // result: (GE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETGE {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64GE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETEQ cmp)) yes no)
+ // cond:
+ // result: (EQ cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETEQ {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64EQ
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETNE cmp)) yes no)
+ // cond:
+ // result: (NE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETNE {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETB cmp)) yes no)
+ // cond:
+ // result: (ULT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETB {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETBE cmp)) yes no)
+ // cond:
+ // result: (ULE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETBE {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETA cmp)) yes no)
+ // cond:
+ // result: (UGT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETA {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETAE cmp)) yes no)
+ // cond:
+ // result: (UGE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETAE {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETGF cmp)) yes no)
+ // cond:
+ // result: (UGT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETGF {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETGEF cmp)) yes no)
+ // cond:
+ // result: (UGE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETGEF {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETEQF cmp)) yes no)
+ // cond:
+ // result: (EQF cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETEQF {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64EQF
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (TESTB (SETNEF cmp)) yes no)
+ // cond:
+ // result: (NEF cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64TESTB {
+ break
+ }
+ if v.Args[0].Op != OpAMD64SETNEF {
+ break
+ }
+ cmp := v.Args[0].Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NEF
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (NE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64NE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (NE (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (NE (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockAMD64UGE:
+ // match: (UGE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (ULE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (UGE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (UGE (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (UGE (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (UGE (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (UGE (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockAMD64UGT:
+ // match: (UGT (InvertFlags cmp) yes no)
+ // cond:
+ // result: (ULT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64ULT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (UGT (FlagEQ) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (UGT (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (UGT (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (UGT (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (UGT (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ case BlockAMD64ULE:
+ // match: (ULE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (UGE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGE
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULE (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULE (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (ULE (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULE (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ case BlockAMD64ULT:
+ // match: (ULT (InvertFlags cmp) yes no)
+ // cond:
+ // result: (UGT cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockAMD64UGT
+ b.Control = cmp
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULT (FlagEQ) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagEQ {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (ULT (FlagLT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULT (FlagLT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagLT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (ULT (FlagGT_ULT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_ULT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (ULT (FlagGT_UGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpAMD64FlagGT_UGT {
+ break
+ }
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ }
+ return false
+}
diff --git a/src/cmd/compile/internal/ssa/rewrite_test.go b/src/cmd/compile/internal/ssa/rewrite_test.go
new file mode 100644
index 0000000..b786df8
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/rewrite_test.go
@@ -0,0 +1,102 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+// TestNlzNto tests nlz/nto of the same number which is used in some of
+// the rewrite rules.
+func TestNlzNto(t *testing.T) {
+ // construct the bit pattern 000...111, nlz(x) + nto(0) = 64
+ var x int64
+ for i := int64(0); i < 64; i++ {
+ if got := nto(x); got != i {
+ t.Errorf("expected nto(0x%X) = %d, got %d", x, i, got)
+ }
+ if got := nlz(x); got != 64-i {
+ t.Errorf("expected nlz(0x%X) = %d, got %d", x, 64-i, got)
+ }
+ x = (x << 1) | 1
+ }
+
+ x = 0
+ // construct the bit pattern 000...111, with bit 33 set as well.
+ for i := int64(0); i < 64; i++ {
+ tx := x | (1 << 32)
+ // nto should be the the number of bits we've shifted on, with an extra bit
+ // at iter 32
+ ntoExp := i
+ if ntoExp == 32 {
+ ntoExp = 33
+ }
+ if got := nto(tx); got != ntoExp {
+ t.Errorf("expected nto(0x%X) = %d, got %d", tx, ntoExp, got)
+ }
+
+ // sinec bit 33 is set, nlz can be no greater than 31
+ nlzExp := 64 - i
+ if nlzExp > 31 {
+ nlzExp = 31
+ }
+ if got := nlz(tx); got != nlzExp {
+ t.Errorf("expected nlz(0x%X) = %d, got %d", tx, nlzExp, got)
+ }
+ x = (x << 1) | 1
+ }
+
+}
+
+func TestNlz(t *testing.T) {
+ var nlzTests = []struct {
+ v int64
+ exp int64
+ }{{0x00, 64},
+ {0x01, 63},
+ {0x0F, 60},
+ {0xFF, 56},
+ {0xffffFFFF, 32},
+ {-0x01, 0}}
+
+ for _, tc := range nlzTests {
+ if got := nlz(tc.v); got != tc.exp {
+ t.Errorf("expected nlz(0x%X) = %d, got %d", tc.v, tc.exp, got)
+ }
+ }
+}
+
+func TestNto(t *testing.T) {
+ var ntoTests = []struct {
+ v int64
+ exp int64
+ }{{0x00, 0},
+ {0x01, 1},
+ {0x0F, 4},
+ {0xFF, 8},
+ {0xffffFFFF, 32},
+ {-0x01, 64}}
+
+ for _, tc := range ntoTests {
+ if got := nto(tc.v); got != tc.exp {
+ t.Errorf("expected nto(0x%X) = %d, got %d", tc.v, tc.exp, got)
+ }
+ }
+}
+
+func TestLog2(t *testing.T) {
+ var log2Tests = []struct {
+ v int64
+ exp int64
+ }{{0, -1}, // nlz expects log2(0) == -1
+ {1, 0},
+ {2, 1},
+ {4, 2},
+ {1024, 10}}
+
+ for _, tc := range log2Tests {
+ if got := log2(tc.v); got != tc.exp {
+ t.Errorf("expected log2(%d) = %d, got %d", tc.v, tc.exp, got)
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
new file mode 100644
index 0000000..ad2abc5
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -0,0 +1,7936 @@
+// autogenerated from gen/generic.rules: do not edit!
+// generated with: cd gen; go run *.go
+
+package ssa
+
+import "math"
+
+var _ = math.MinInt8 // in case not otherwise used
+func rewriteValuegeneric(v *Value, config *Config) bool {
+ switch v.Op {
+ case OpAdd16:
+ return rewriteValuegeneric_OpAdd16(v, config)
+ case OpAdd32:
+ return rewriteValuegeneric_OpAdd32(v, config)
+ case OpAdd64:
+ return rewriteValuegeneric_OpAdd64(v, config)
+ case OpAdd8:
+ return rewriteValuegeneric_OpAdd8(v, config)
+ case OpAnd16:
+ return rewriteValuegeneric_OpAnd16(v, config)
+ case OpAnd32:
+ return rewriteValuegeneric_OpAnd32(v, config)
+ case OpAnd64:
+ return rewriteValuegeneric_OpAnd64(v, config)
+ case OpAnd8:
+ return rewriteValuegeneric_OpAnd8(v, config)
+ case OpArg:
+ return rewriteValuegeneric_OpArg(v, config)
+ case OpArrayIndex:
+ return rewriteValuegeneric_OpArrayIndex(v, config)
+ case OpCom16:
+ return rewriteValuegeneric_OpCom16(v, config)
+ case OpCom32:
+ return rewriteValuegeneric_OpCom32(v, config)
+ case OpCom64:
+ return rewriteValuegeneric_OpCom64(v, config)
+ case OpCom8:
+ return rewriteValuegeneric_OpCom8(v, config)
+ case OpComplexImag:
+ return rewriteValuegeneric_OpComplexImag(v, config)
+ case OpComplexReal:
+ return rewriteValuegeneric_OpComplexReal(v, config)
+ case OpConstInterface:
+ return rewriteValuegeneric_OpConstInterface(v, config)
+ case OpConstSlice:
+ return rewriteValuegeneric_OpConstSlice(v, config)
+ case OpConstString:
+ return rewriteValuegeneric_OpConstString(v, config)
+ case OpConvert:
+ return rewriteValuegeneric_OpConvert(v, config)
+ case OpDiv64:
+ return rewriteValuegeneric_OpDiv64(v, config)
+ case OpDiv64u:
+ return rewriteValuegeneric_OpDiv64u(v, config)
+ case OpEq16:
+ return rewriteValuegeneric_OpEq16(v, config)
+ case OpEq32:
+ return rewriteValuegeneric_OpEq32(v, config)
+ case OpEq64:
+ return rewriteValuegeneric_OpEq64(v, config)
+ case OpEq8:
+ return rewriteValuegeneric_OpEq8(v, config)
+ case OpEqInter:
+ return rewriteValuegeneric_OpEqInter(v, config)
+ case OpEqPtr:
+ return rewriteValuegeneric_OpEqPtr(v, config)
+ case OpEqSlice:
+ return rewriteValuegeneric_OpEqSlice(v, config)
+ case OpGeq16:
+ return rewriteValuegeneric_OpGeq16(v, config)
+ case OpGeq16U:
+ return rewriteValuegeneric_OpGeq16U(v, config)
+ case OpGeq32:
+ return rewriteValuegeneric_OpGeq32(v, config)
+ case OpGeq32U:
+ return rewriteValuegeneric_OpGeq32U(v, config)
+ case OpGeq64:
+ return rewriteValuegeneric_OpGeq64(v, config)
+ case OpGeq64U:
+ return rewriteValuegeneric_OpGeq64U(v, config)
+ case OpGeq8:
+ return rewriteValuegeneric_OpGeq8(v, config)
+ case OpGeq8U:
+ return rewriteValuegeneric_OpGeq8U(v, config)
+ case OpGreater16:
+ return rewriteValuegeneric_OpGreater16(v, config)
+ case OpGreater16U:
+ return rewriteValuegeneric_OpGreater16U(v, config)
+ case OpGreater32:
+ return rewriteValuegeneric_OpGreater32(v, config)
+ case OpGreater32U:
+ return rewriteValuegeneric_OpGreater32U(v, config)
+ case OpGreater64:
+ return rewriteValuegeneric_OpGreater64(v, config)
+ case OpGreater64U:
+ return rewriteValuegeneric_OpGreater64U(v, config)
+ case OpGreater8:
+ return rewriteValuegeneric_OpGreater8(v, config)
+ case OpGreater8U:
+ return rewriteValuegeneric_OpGreater8U(v, config)
+ case OpIData:
+ return rewriteValuegeneric_OpIData(v, config)
+ case OpITab:
+ return rewriteValuegeneric_OpITab(v, config)
+ case OpIsInBounds:
+ return rewriteValuegeneric_OpIsInBounds(v, config)
+ case OpIsSliceInBounds:
+ return rewriteValuegeneric_OpIsSliceInBounds(v, config)
+ case OpLeq16:
+ return rewriteValuegeneric_OpLeq16(v, config)
+ case OpLeq16U:
+ return rewriteValuegeneric_OpLeq16U(v, config)
+ case OpLeq32:
+ return rewriteValuegeneric_OpLeq32(v, config)
+ case OpLeq32U:
+ return rewriteValuegeneric_OpLeq32U(v, config)
+ case OpLeq64:
+ return rewriteValuegeneric_OpLeq64(v, config)
+ case OpLeq64U:
+ return rewriteValuegeneric_OpLeq64U(v, config)
+ case OpLeq8:
+ return rewriteValuegeneric_OpLeq8(v, config)
+ case OpLeq8U:
+ return rewriteValuegeneric_OpLeq8U(v, config)
+ case OpLess16:
+ return rewriteValuegeneric_OpLess16(v, config)
+ case OpLess16U:
+ return rewriteValuegeneric_OpLess16U(v, config)
+ case OpLess32:
+ return rewriteValuegeneric_OpLess32(v, config)
+ case OpLess32U:
+ return rewriteValuegeneric_OpLess32U(v, config)
+ case OpLess64:
+ return rewriteValuegeneric_OpLess64(v, config)
+ case OpLess64U:
+ return rewriteValuegeneric_OpLess64U(v, config)
+ case OpLess8:
+ return rewriteValuegeneric_OpLess8(v, config)
+ case OpLess8U:
+ return rewriteValuegeneric_OpLess8U(v, config)
+ case OpLoad:
+ return rewriteValuegeneric_OpLoad(v, config)
+ case OpLsh16x16:
+ return rewriteValuegeneric_OpLsh16x16(v, config)
+ case OpLsh16x32:
+ return rewriteValuegeneric_OpLsh16x32(v, config)
+ case OpLsh16x64:
+ return rewriteValuegeneric_OpLsh16x64(v, config)
+ case OpLsh16x8:
+ return rewriteValuegeneric_OpLsh16x8(v, config)
+ case OpLsh32x16:
+ return rewriteValuegeneric_OpLsh32x16(v, config)
+ case OpLsh32x32:
+ return rewriteValuegeneric_OpLsh32x32(v, config)
+ case OpLsh32x64:
+ return rewriteValuegeneric_OpLsh32x64(v, config)
+ case OpLsh32x8:
+ return rewriteValuegeneric_OpLsh32x8(v, config)
+ case OpLsh64x16:
+ return rewriteValuegeneric_OpLsh64x16(v, config)
+ case OpLsh64x32:
+ return rewriteValuegeneric_OpLsh64x32(v, config)
+ case OpLsh64x64:
+ return rewriteValuegeneric_OpLsh64x64(v, config)
+ case OpLsh64x8:
+ return rewriteValuegeneric_OpLsh64x8(v, config)
+ case OpLsh8x16:
+ return rewriteValuegeneric_OpLsh8x16(v, config)
+ case OpLsh8x32:
+ return rewriteValuegeneric_OpLsh8x32(v, config)
+ case OpLsh8x64:
+ return rewriteValuegeneric_OpLsh8x64(v, config)
+ case OpLsh8x8:
+ return rewriteValuegeneric_OpLsh8x8(v, config)
+ case OpMod64:
+ return rewriteValuegeneric_OpMod64(v, config)
+ case OpMod64u:
+ return rewriteValuegeneric_OpMod64u(v, config)
+ case OpMul16:
+ return rewriteValuegeneric_OpMul16(v, config)
+ case OpMul32:
+ return rewriteValuegeneric_OpMul32(v, config)
+ case OpMul64:
+ return rewriteValuegeneric_OpMul64(v, config)
+ case OpMul8:
+ return rewriteValuegeneric_OpMul8(v, config)
+ case OpNeg16:
+ return rewriteValuegeneric_OpNeg16(v, config)
+ case OpNeg32:
+ return rewriteValuegeneric_OpNeg32(v, config)
+ case OpNeg64:
+ return rewriteValuegeneric_OpNeg64(v, config)
+ case OpNeg8:
+ return rewriteValuegeneric_OpNeg8(v, config)
+ case OpNeq16:
+ return rewriteValuegeneric_OpNeq16(v, config)
+ case OpNeq32:
+ return rewriteValuegeneric_OpNeq32(v, config)
+ case OpNeq64:
+ return rewriteValuegeneric_OpNeq64(v, config)
+ case OpNeq8:
+ return rewriteValuegeneric_OpNeq8(v, config)
+ case OpNeqInter:
+ return rewriteValuegeneric_OpNeqInter(v, config)
+ case OpNeqPtr:
+ return rewriteValuegeneric_OpNeqPtr(v, config)
+ case OpNeqSlice:
+ return rewriteValuegeneric_OpNeqSlice(v, config)
+ case OpOr16:
+ return rewriteValuegeneric_OpOr16(v, config)
+ case OpOr32:
+ return rewriteValuegeneric_OpOr32(v, config)
+ case OpOr64:
+ return rewriteValuegeneric_OpOr64(v, config)
+ case OpOr8:
+ return rewriteValuegeneric_OpOr8(v, config)
+ case OpPhi:
+ return rewriteValuegeneric_OpPhi(v, config)
+ case OpPtrIndex:
+ return rewriteValuegeneric_OpPtrIndex(v, config)
+ case OpRsh16Ux16:
+ return rewriteValuegeneric_OpRsh16Ux16(v, config)
+ case OpRsh16Ux32:
+ return rewriteValuegeneric_OpRsh16Ux32(v, config)
+ case OpRsh16Ux64:
+ return rewriteValuegeneric_OpRsh16Ux64(v, config)
+ case OpRsh16Ux8:
+ return rewriteValuegeneric_OpRsh16Ux8(v, config)
+ case OpRsh16x16:
+ return rewriteValuegeneric_OpRsh16x16(v, config)
+ case OpRsh16x32:
+ return rewriteValuegeneric_OpRsh16x32(v, config)
+ case OpRsh16x64:
+ return rewriteValuegeneric_OpRsh16x64(v, config)
+ case OpRsh16x8:
+ return rewriteValuegeneric_OpRsh16x8(v, config)
+ case OpRsh32Ux16:
+ return rewriteValuegeneric_OpRsh32Ux16(v, config)
+ case OpRsh32Ux32:
+ return rewriteValuegeneric_OpRsh32Ux32(v, config)
+ case OpRsh32Ux64:
+ return rewriteValuegeneric_OpRsh32Ux64(v, config)
+ case OpRsh32Ux8:
+ return rewriteValuegeneric_OpRsh32Ux8(v, config)
+ case OpRsh32x16:
+ return rewriteValuegeneric_OpRsh32x16(v, config)
+ case OpRsh32x32:
+ return rewriteValuegeneric_OpRsh32x32(v, config)
+ case OpRsh32x64:
+ return rewriteValuegeneric_OpRsh32x64(v, config)
+ case OpRsh32x8:
+ return rewriteValuegeneric_OpRsh32x8(v, config)
+ case OpRsh64Ux16:
+ return rewriteValuegeneric_OpRsh64Ux16(v, config)
+ case OpRsh64Ux32:
+ return rewriteValuegeneric_OpRsh64Ux32(v, config)
+ case OpRsh64Ux64:
+ return rewriteValuegeneric_OpRsh64Ux64(v, config)
+ case OpRsh64Ux8:
+ return rewriteValuegeneric_OpRsh64Ux8(v, config)
+ case OpRsh64x16:
+ return rewriteValuegeneric_OpRsh64x16(v, config)
+ case OpRsh64x32:
+ return rewriteValuegeneric_OpRsh64x32(v, config)
+ case OpRsh64x64:
+ return rewriteValuegeneric_OpRsh64x64(v, config)
+ case OpRsh64x8:
+ return rewriteValuegeneric_OpRsh64x8(v, config)
+ case OpRsh8Ux16:
+ return rewriteValuegeneric_OpRsh8Ux16(v, config)
+ case OpRsh8Ux32:
+ return rewriteValuegeneric_OpRsh8Ux32(v, config)
+ case OpRsh8Ux64:
+ return rewriteValuegeneric_OpRsh8Ux64(v, config)
+ case OpRsh8Ux8:
+ return rewriteValuegeneric_OpRsh8Ux8(v, config)
+ case OpRsh8x16:
+ return rewriteValuegeneric_OpRsh8x16(v, config)
+ case OpRsh8x32:
+ return rewriteValuegeneric_OpRsh8x32(v, config)
+ case OpRsh8x64:
+ return rewriteValuegeneric_OpRsh8x64(v, config)
+ case OpRsh8x8:
+ return rewriteValuegeneric_OpRsh8x8(v, config)
+ case OpSliceCap:
+ return rewriteValuegeneric_OpSliceCap(v, config)
+ case OpSliceLen:
+ return rewriteValuegeneric_OpSliceLen(v, config)
+ case OpSlicePtr:
+ return rewriteValuegeneric_OpSlicePtr(v, config)
+ case OpStore:
+ return rewriteValuegeneric_OpStore(v, config)
+ case OpStringLen:
+ return rewriteValuegeneric_OpStringLen(v, config)
+ case OpStringPtr:
+ return rewriteValuegeneric_OpStringPtr(v, config)
+ case OpStructSelect:
+ return rewriteValuegeneric_OpStructSelect(v, config)
+ case OpSub16:
+ return rewriteValuegeneric_OpSub16(v, config)
+ case OpSub32:
+ return rewriteValuegeneric_OpSub32(v, config)
+ case OpSub64:
+ return rewriteValuegeneric_OpSub64(v, config)
+ case OpSub8:
+ return rewriteValuegeneric_OpSub8(v, config)
+ case OpTrunc16to8:
+ return rewriteValuegeneric_OpTrunc16to8(v, config)
+ case OpTrunc32to16:
+ return rewriteValuegeneric_OpTrunc32to16(v, config)
+ case OpTrunc32to8:
+ return rewriteValuegeneric_OpTrunc32to8(v, config)
+ case OpTrunc64to16:
+ return rewriteValuegeneric_OpTrunc64to16(v, config)
+ case OpTrunc64to32:
+ return rewriteValuegeneric_OpTrunc64to32(v, config)
+ case OpTrunc64to8:
+ return rewriteValuegeneric_OpTrunc64to8(v, config)
+ case OpXor16:
+ return rewriteValuegeneric_OpXor16(v, config)
+ case OpXor32:
+ return rewriteValuegeneric_OpXor32(v, config)
+ case OpXor64:
+ return rewriteValuegeneric_OpXor64(v, config)
+ case OpXor8:
+ return rewriteValuegeneric_OpXor8(v, config)
+ }
+ return false
+}
+func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (Const16 [c+d])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (Add16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Add16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpAdd16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Add16 (Const16 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (Const32 [c+d])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (Add32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Add32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpAdd32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Add32 (Const32 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [c+d])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (Add64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Add64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpAdd64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Add64 (Const64 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Add8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (Const8 [c+d])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = c + d
+ return true
+ }
+ // match: (Add8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Add8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpAdd8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Add8 (Const8 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (And16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpAnd16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (And16 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And16 (Const16 [-1]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And16 (Const16 [0]) _)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (And32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpAnd32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (And32 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And32 (Const32 [-1]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And32 (Const32 [0]) _)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (And32 <t> (Const32 [y]) x)
+ // cond: nlz(int64(int32(y))) + nto(int64(int32(y))) == 64
+ // result: (Rsh32Ux32 (Lsh32x32 <t> x (Const32 <t> [nlz(int64(int32(y)))-32])) (Const32 <t> [nlz(int64(int32(y)))-32]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ y := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(nlz(int64(int32(y)))+nto(int64(int32(y))) == 64) {
+ break
+ }
+ v.reset(OpRsh32Ux32)
+ v0 := b.NewValue0(v.Line, OpLsh32x32, t)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Line, OpConst32, t)
+ v1.AuxInt = nlz(int64(int32(y))) - 32
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst32, t)
+ v2.AuxInt = nlz(int64(int32(y))) - 32
+ v.AddArg(v2)
+ return true
+ }
+ // match: (And32 <t> (Const32 [y]) x)
+ // cond: nlo(int64(int32(y))) + ntz(int64(int32(y))) == 64
+ // result: (Lsh32x32 (Rsh32Ux32 <t> x (Const32 <t> [ntz(int64(int32(y)))])) (Const32 <t> [ntz(int64(int32(y)))]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ y := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(nlo(int64(int32(y)))+ntz(int64(int32(y))) == 64) {
+ break
+ }
+ v.reset(OpLsh32x32)
+ v0 := b.NewValue0(v.Line, OpRsh32Ux32, t)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Line, OpConst32, t)
+ v1.AuxInt = ntz(int64(int32(y)))
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst32, t)
+ v2.AuxInt = ntz(int64(int32(y)))
+ v.AddArg(v2)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (And64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpAnd64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (And64 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And64 (Const64 [-1]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (And64 <t> (Const64 [y]) x)
+ // cond: nlz(y) + nto(y) == 64
+ // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ y := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(nlz(y)+nto(y) == 64) {
+ break
+ }
+ v.reset(OpRsh64Ux64)
+ v0 := b.NewValue0(v.Line, OpLsh64x64, t)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Line, OpConst64, t)
+ v1.AuxInt = nlz(y)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = nlz(y)
+ v.AddArg(v2)
+ return true
+ }
+ // match: (And64 <t> (Const64 [y]) x)
+ // cond: nlo(y) + ntz(y) == 64
+ // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ y := v.Args[0].AuxInt
+ x := v.Args[1]
+ if !(nlo(y)+ntz(y) == 64) {
+ break
+ }
+ v.reset(OpLsh64x64)
+ v0 := b.NewValue0(v.Line, OpRsh64Ux64, t)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Line, OpConst64, t)
+ v1.AuxInt = ntz(y)
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = ntz(y)
+ v.AddArg(v2)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (And8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (And8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpAnd8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (And8 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And8 (Const8 [-1]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (And8 (Const8 [0]) _)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpArg(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Arg {n} [off])
+ // cond: v.Type.IsString()
+ // result: (StringMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]))
+ for {
+ n := v.Aux
+ off := v.AuxInt
+ if !(v.Type.IsString()) {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
+ v0.Aux = n
+ v0.AuxInt = off
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt())
+ v1.Aux = n
+ v1.AuxInt = off + config.PtrSize
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Arg {n} [off])
+ // cond: v.Type.IsSlice()
+ // result: (SliceMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <config.fe.TypeInt()> {n} [off+2*config.PtrSize]))
+ for {
+ n := v.Aux
+ off := v.AuxInt
+ if !(v.Type.IsSlice()) {
+ break
+ }
+ v.reset(OpSliceMake)
+ v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
+ v0.Aux = n
+ v0.AuxInt = off
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt())
+ v1.Aux = n
+ v1.AuxInt = off + config.PtrSize
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt())
+ v2.Aux = n
+ v2.AuxInt = off + 2*config.PtrSize
+ v.AddArg(v2)
+ return true
+ }
+ // match: (Arg {n} [off])
+ // cond: v.Type.IsInterface()
+ // result: (IMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeBytePtr()> {n} [off+config.PtrSize]))
+ for {
+ n := v.Aux
+ off := v.AuxInt
+ if !(v.Type.IsInterface()) {
+ break
+ }
+ v.reset(OpIMake)
+ v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
+ v0.Aux = n
+ v0.AuxInt = off
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
+ v1.Aux = n
+ v1.AuxInt = off + config.PtrSize
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Arg {n} [off])
+ // cond: v.Type.IsComplex() && v.Type.Size() == 16
+ // result: (ComplexMake (Arg <config.fe.TypeFloat64()> {n} [off]) (Arg <config.fe.TypeFloat64()> {n} [off+8]))
+ for {
+ n := v.Aux
+ off := v.AuxInt
+ if !(v.Type.IsComplex() && v.Type.Size() == 16) {
+ break
+ }
+ v.reset(OpComplexMake)
+ v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64())
+ v0.Aux = n
+ v0.AuxInt = off
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64())
+ v1.Aux = n
+ v1.AuxInt = off + 8
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Arg {n} [off])
+ // cond: v.Type.IsComplex() && v.Type.Size() == 8
+ // result: (ComplexMake (Arg <config.fe.TypeFloat32()> {n} [off]) (Arg <config.fe.TypeFloat32()> {n} [off+4]))
+ for {
+ n := v.Aux
+ off := v.AuxInt
+ if !(v.Type.IsComplex() && v.Type.Size() == 8) {
+ break
+ }
+ v.reset(OpComplexMake)
+ v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32())
+ v0.Aux = n
+ v0.AuxInt = off
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32())
+ v1.Aux = n
+ v1.AuxInt = off + 4
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Arg <t>)
+ // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)
+ // result: (StructMake0)
+ for {
+ t := v.Type
+ if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake0)
+ return true
+ }
+ // match: (Arg <t> {n} [off])
+ // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)
+ // result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]))
+ for {
+ t := v.Type
+ n := v.Aux
+ off := v.AuxInt
+ if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake1)
+ v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
+ v0.Aux = n
+ v0.AuxInt = off + t.FieldOff(0)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Arg <t> {n} [off])
+ // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)
+ // result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]))
+ for {
+ t := v.Type
+ n := v.Aux
+ off := v.AuxInt
+ if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake2)
+ v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
+ v0.Aux = n
+ v0.AuxInt = off + t.FieldOff(0)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, t.FieldType(1))
+ v1.Aux = n
+ v1.AuxInt = off + t.FieldOff(1)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Arg <t> {n} [off])
+ // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)
+ // result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]))
+ for {
+ t := v.Type
+ n := v.Aux
+ off := v.AuxInt
+ if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake3)
+ v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
+ v0.Aux = n
+ v0.AuxInt = off + t.FieldOff(0)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, t.FieldType(1))
+ v1.Aux = n
+ v1.AuxInt = off + t.FieldOff(1)
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpArg, t.FieldType(2))
+ v2.Aux = n
+ v2.AuxInt = off + t.FieldOff(2)
+ v.AddArg(v2)
+ return true
+ }
+ // match: (Arg <t> {n} [off])
+ // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)
+ // result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]) (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)]))
+ for {
+ t := v.Type
+ n := v.Aux
+ off := v.AuxInt
+ if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake4)
+ v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
+ v0.Aux = n
+ v0.AuxInt = off + t.FieldOff(0)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpArg, t.FieldType(1))
+ v1.Aux = n
+ v1.AuxInt = off + t.FieldOff(1)
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpArg, t.FieldType(2))
+ v2.Aux = n
+ v2.AuxInt = off + t.FieldOff(2)
+ v.AddArg(v2)
+ v3 := b.NewValue0(v.Line, OpArg, t.FieldType(3))
+ v3.Aux = n
+ v3.AuxInt = off + t.FieldOff(3)
+ v.AddArg(v3)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ArrayIndex (Load ptr mem) idx)
+ // cond: b == v.Args[0].Block
+ // result: (Load (PtrIndex <v.Type.PtrTo()> ptr idx) mem)
+ for {
+ if v.Args[0].Op != OpLoad {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ idx := v.Args[1]
+ if !(b == v.Args[0].Block) {
+ break
+ }
+ v.reset(OpLoad)
+ v0 := b.NewValue0(v.Line, OpPtrIndex, v.Type.PtrTo())
+ v0.AddArg(ptr)
+ v0.AddArg(idx)
+ v.AddArg(v0)
+ v.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com16 (Com16 x))
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpCom16 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com32 (Com32 x))
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpCom32 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com64 (Com64 x))
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpCom64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Com8 (Com8 x))
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpCom8 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ComplexImag (ComplexMake _ imag ))
+ // cond:
+ // result: imag
+ for {
+ if v.Args[0].Op != OpComplexMake {
+ break
+ }
+ imag := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = imag.Type
+ v.AddArg(imag)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ComplexReal (ComplexMake real _ ))
+ // cond:
+ // result: real
+ for {
+ if v.Args[0].Op != OpComplexMake {
+ break
+ }
+ real := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = real.Type
+ v.AddArg(real)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ConstInterface)
+ // cond:
+ // result: (IMake (ConstNil <config.fe.TypeBytePtr()>) (ConstNil <config.fe.TypeBytePtr()>))
+ for {
+ v.reset(OpIMake)
+ v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ConstSlice)
+ // cond: config.PtrSize == 4
+ // result: (SliceMake (ConstNil <config.fe.TypeBytePtr()>) (Const32 <config.fe.TypeInt()> [0]) (Const32 <config.fe.TypeInt()> [0]))
+ for {
+ if !(config.PtrSize == 4) {
+ break
+ }
+ v.reset(OpSliceMake)
+ v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt())
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt())
+ v2.AuxInt = 0
+ v.AddArg(v2)
+ return true
+ }
+ // match: (ConstSlice)
+ // cond: config.PtrSize == 8
+ // result: (SliceMake (ConstNil <config.fe.TypeBytePtr()>) (Const64 <config.fe.TypeInt()> [0]) (Const64 <config.fe.TypeInt()> [0]))
+ for {
+ if !(config.PtrSize == 8) {
+ break
+ }
+ v.reset(OpSliceMake)
+ v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt())
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt())
+ v2.AuxInt = 0
+ v.AddArg(v2)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ConstString {s})
+ // cond: config.PtrSize == 4 && s.(string) == ""
+ // result: (StringMake (ConstNil) (Const32 <config.fe.TypeInt()> [0]))
+ for {
+ s := v.Aux
+ if !(config.PtrSize == 4 && s.(string) == "") {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt())
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ return true
+ }
+ // match: (ConstString {s})
+ // cond: config.PtrSize == 8 && s.(string) == ""
+ // result: (StringMake (ConstNil) (Const64 <config.fe.TypeInt()> [0]))
+ for {
+ s := v.Aux
+ if !(config.PtrSize == 8 && s.(string) == "") {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt())
+ v1.AuxInt = 0
+ v.AddArg(v1)
+ return true
+ }
+ // match: (ConstString {s})
+ // cond: config.PtrSize == 4 && s.(string) != ""
+ // result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const32 <config.fe.TypeInt()> [int64(len(s.(string)))]))
+ for {
+ s := v.Aux
+ if !(config.PtrSize == 4 && s.(string) != "") {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr())
+ v0.Aux = config.fe.StringData(s.(string))
+ v1 := b.NewValue0(v.Line, OpSB, config.fe.TypeUintptr())
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt())
+ v2.AuxInt = int64(len(s.(string)))
+ v.AddArg(v2)
+ return true
+ }
+ // match: (ConstString {s})
+ // cond: config.PtrSize == 8 && s.(string) != ""
+ // result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const64 <config.fe.TypeInt()> [int64(len(s.(string)))]))
+ for {
+ s := v.Aux
+ if !(config.PtrSize == 8 && s.(string) != "") {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr())
+ v0.Aux = config.fe.StringData(s.(string))
+ v1 := b.NewValue0(v.Line, OpSB, config.fe.TypeUintptr())
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt())
+ v2.AuxInt = int64(len(s.(string)))
+ v.AddArg(v2)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Convert (Add64 (Convert ptr mem) off) mem)
+ // cond:
+ // result: (Add64 ptr off)
+ for {
+ if v.Args[0].Op != OpAdd64 {
+ break
+ }
+ if v.Args[0].Args[0].Op != OpConvert {
+ break
+ }
+ ptr := v.Args[0].Args[0].Args[0]
+ mem := v.Args[0].Args[0].Args[1]
+ off := v.Args[0].Args[1]
+ if v.Args[1] != mem {
+ break
+ }
+ v.reset(OpAdd64)
+ v.AddArg(ptr)
+ v.AddArg(off)
+ return true
+ }
+ // match: (Convert (Add64 off (Convert ptr mem)) mem)
+ // cond:
+ // result: (Add64 ptr off)
+ for {
+ if v.Args[0].Op != OpAdd64 {
+ break
+ }
+ off := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConvert {
+ break
+ }
+ ptr := v.Args[0].Args[1].Args[0]
+ mem := v.Args[0].Args[1].Args[1]
+ if v.Args[1] != mem {
+ break
+ }
+ v.reset(OpAdd64)
+ v.AddArg(ptr)
+ v.AddArg(off)
+ return true
+ }
+ // match: (Convert (Convert ptr mem) mem)
+ // cond:
+ // result: ptr
+ for {
+ if v.Args[0].Op != OpConvert {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ if v.Args[1] != mem {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = ptr.Type
+ v.AddArg(ptr)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div64 <t> x (Const64 [c]))
+ // cond: c > 0 && smagic64ok(c) && smagic64m(c) > 0
+ // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <t> [smagic64m(c)]) x) (Const64 <t> [smagic64s(c)])) (Rsh64x64 <t> x (Const64 <t> [63])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(c > 0 && smagic64ok(c) && smagic64m(c) > 0) {
+ break
+ }
+ v.reset(OpSub64)
+ v.Type = t
+ v0 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v1 := b.NewValue0(v.Line, OpHmul64, t)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = smagic64m(c)
+ v1.AddArg(v2)
+ v1.AddArg(x)
+ v0.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = smagic64s(c)
+ v0.AddArg(v3)
+ v.AddArg(v0)
+ v4 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v4.AddArg(x)
+ v5 := b.NewValue0(v.Line, OpConst64, t)
+ v5.AuxInt = 63
+ v4.AddArg(v5)
+ v.AddArg(v4)
+ return true
+ }
+ // match: (Div64 <t> x (Const64 [c]))
+ // cond: c > 0 && smagic64ok(c) && smagic64m(c) < 0
+ // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <t> [smagic64m(c)]) x) x) (Const64 <t> [smagic64s(c)])) (Rsh64x64 <t> x (Const64 <t> [63])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(c > 0 && smagic64ok(c) && smagic64m(c) < 0) {
+ break
+ }
+ v.reset(OpSub64)
+ v.Type = t
+ v0 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v1 := b.NewValue0(v.Line, OpAdd64, t)
+ v2 := b.NewValue0(v.Line, OpHmul64, t)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = smagic64m(c)
+ v2.AddArg(v3)
+ v2.AddArg(x)
+ v1.AddArg(v2)
+ v1.AddArg(x)
+ v0.AddArg(v1)
+ v4 := b.NewValue0(v.Line, OpConst64, t)
+ v4.AuxInt = smagic64s(c)
+ v0.AddArg(v4)
+ v.AddArg(v0)
+ v5 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v5.AddArg(x)
+ v6 := b.NewValue0(v.Line, OpConst64, t)
+ v6.AuxInt = 63
+ v5.AddArg(v6)
+ v.AddArg(v5)
+ return true
+ }
+ // match: (Div64 <t> x (Const64 [c]))
+ // cond: c < 0 && smagic64ok(c) && smagic64m(c) > 0
+ // result: (Neg64 <t> (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <t> [smagic64m(c)]) x) (Const64 <t> [smagic64s(c)])) (Rsh64x64 <t> x (Const64 <t> [63]))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(c < 0 && smagic64ok(c) && smagic64m(c) > 0) {
+ break
+ }
+ v.reset(OpNeg64)
+ v.Type = t
+ v0 := b.NewValue0(v.Line, OpSub64, t)
+ v1 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v2 := b.NewValue0(v.Line, OpHmul64, t)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = smagic64m(c)
+ v2.AddArg(v3)
+ v2.AddArg(x)
+ v1.AddArg(v2)
+ v4 := b.NewValue0(v.Line, OpConst64, t)
+ v4.AuxInt = smagic64s(c)
+ v1.AddArg(v4)
+ v0.AddArg(v1)
+ v5 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v5.AddArg(x)
+ v6 := b.NewValue0(v.Line, OpConst64, t)
+ v6.AuxInt = 63
+ v5.AddArg(v6)
+ v0.AddArg(v5)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Div64 <t> x (Const64 [c]))
+ // cond: c < 0 && smagic64ok(c) && smagic64m(c) < 0
+ // result: (Neg64 <t> (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <t> [smagic64m(c)]) x) x) (Const64 <t> [smagic64s(c)])) (Rsh64x64 <t> x (Const64 <t> [63]))))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(c < 0 && smagic64ok(c) && smagic64m(c) < 0) {
+ break
+ }
+ v.reset(OpNeg64)
+ v.Type = t
+ v0 := b.NewValue0(v.Line, OpSub64, t)
+ v1 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v2 := b.NewValue0(v.Line, OpAdd64, t)
+ v3 := b.NewValue0(v.Line, OpHmul64, t)
+ v4 := b.NewValue0(v.Line, OpConst64, t)
+ v4.AuxInt = smagic64m(c)
+ v3.AddArg(v4)
+ v3.AddArg(x)
+ v2.AddArg(v3)
+ v2.AddArg(x)
+ v1.AddArg(v2)
+ v5 := b.NewValue0(v.Line, OpConst64, t)
+ v5.AuxInt = smagic64s(c)
+ v1.AddArg(v5)
+ v0.AddArg(v1)
+ v6 := b.NewValue0(v.Line, OpRsh64x64, t)
+ v6.AddArg(x)
+ v7 := b.NewValue0(v.Line, OpConst64, t)
+ v7.AuxInt = 63
+ v6.AddArg(v7)
+ v0.AddArg(v6)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Div64u <t> x (Const64 [c]))
+ // cond: umagic64ok(c) && !umagic64a(c)
+ // result: (Rsh64Ux64 (Hmul64u <t> (Const64 <t> [umagic64m(c)]) x) (Const64 <t> [umagic64s(c)]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(umagic64ok(c) && !umagic64a(c)) {
+ break
+ }
+ v.reset(OpRsh64Ux64)
+ v0 := b.NewValue0(v.Line, OpHmul64u, t)
+ v1 := b.NewValue0(v.Line, OpConst64, t)
+ v1.AuxInt = umagic64m(c)
+ v0.AddArg(v1)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = umagic64s(c)
+ v.AddArg(v2)
+ return true
+ }
+ // match: (Div64u <t> x (Const64 [c]))
+ // cond: umagic64ok(c) && umagic64a(c)
+ // result: (Rsh64Ux64 (Avg64u <t> (Hmul64u <t> x (Const64 <t> [umagic64m(c)])) x) (Const64 <t> [umagic64s(c)-1]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(umagic64ok(c) && umagic64a(c)) {
+ break
+ }
+ v.reset(OpRsh64Ux64)
+ v0 := b.NewValue0(v.Line, OpAvg64u, t)
+ v1 := b.NewValue0(v.Line, OpHmul64u, t)
+ v1.AddArg(x)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = umagic64m(c)
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = umagic64s(c) - 1
+ v.AddArg(v3)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq16 x x)
+ // cond:
+ // result: (ConstBool [1])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
+ // cond:
+ // result: (Eq16 (Const16 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd16 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpEq16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Eq16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpEq16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) == int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) == int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq32 x x)
+ // cond:
+ // result: (ConstBool [1])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
+ // cond:
+ // result: (Eq32 (Const32 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd32 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpEq32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Eq32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpEq32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) == int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) == int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq64 x x)
+ // cond:
+ // result: (ConstBool [1])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
+ // cond:
+ // result: (Eq64 (Const64 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd64 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpEq64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Eq64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpEq64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) == int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) == int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Eq8 x x)
+ // cond:
+ // result: (ConstBool [1])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 1
+ return true
+ }
+ // match: (Eq8 (ConstBool [c]) (ConstBool [d]))
+ // cond:
+ // result: (ConstBool [b2i((int8(c) != 0) == (int8(d) != 0))])
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConstBool {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i((int8(c) != 0) == (int8(d) != 0))
+ return true
+ }
+ // match: (Eq8 (ConstBool [0]) x)
+ // cond:
+ // result: (Not x)
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpNot)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq8 (ConstBool [1]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ if v.Args[0].AuxInt != 1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
+ // cond:
+ // result: (Eq8 (Const8 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd8 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpEq8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Eq8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpEq8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq8 x (ConstBool <t> [c]))
+ // cond: x.Op != OpConstBool
+ // result: (Eq8 (ConstBool <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConstBool {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConstBool) {
+ break
+ }
+ v.reset(OpEq8)
+ v0 := b.NewValue0(v.Line, OpConstBool, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Eq8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) == int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) == int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (EqInter x y)
+ // cond:
+ // result: (EqPtr (ITab x) (ITab y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpEqPtr)
+ v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (EqPtr p (ConstNil))
+ // cond:
+ // result: (Not (IsNonNil p))
+ for {
+ p := v.Args[0]
+ if v.Args[1].Op != OpConstNil {
+ break
+ }
+ v.reset(OpNot)
+ v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool())
+ v0.AddArg(p)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (EqPtr (ConstNil) p)
+ // cond:
+ // result: (Not (IsNonNil p))
+ for {
+ if v.Args[0].Op != OpConstNil {
+ break
+ }
+ p := v.Args[1]
+ v.reset(OpNot)
+ v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool())
+ v0.AddArg(p)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (EqSlice x y)
+ // cond:
+ // result: (EqPtr (SlicePtr x) (SlicePtr y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpEqPtr)
+ v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) >= int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) >= int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq16U (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint16(c) >= uint16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint16(c) >= uint16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) >= int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) >= int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq32U (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint32(c) >= uint32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint32(c) >= uint32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) >= int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) >= int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq64U (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint64(c) >= uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint64(c) >= uint64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) >= int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) >= int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Geq8U (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint8(c) >= uint8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint8(c) >= uint8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) > int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) > int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater16U (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint16(c) > uint16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint16(c) > uint16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) > int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) > int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater32U (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint32(c) > uint32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint32(c) > uint32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) > int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) > int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater64U (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint64(c) > uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint64(c) > uint64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) > int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) > int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Greater8U (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint8(c) > uint8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint8(c) > uint8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpIData(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IData (IMake _ data))
+ // cond:
+ // result: data
+ for {
+ if v.Args[0].Op != OpIMake {
+ break
+ }
+ data := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = data.Type
+ v.AddArg(data)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpITab(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (ITab (IMake itab _))
+ // cond:
+ // result: itab
+ for {
+ if v.Args[0].Op != OpIMake {
+ break
+ }
+ itab := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = itab.Type
+ v.AddArg(itab)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IsInBounds (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(inBounds32(c,d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(inBounds32(c, d))
+ return true
+ }
+ // match: (IsInBounds (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(inBounds64(c,d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(inBounds64(c, d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(sliceInBounds32(c,d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(sliceInBounds32(c, d))
+ return true
+ }
+ // match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(sliceInBounds64(c,d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(sliceInBounds64(c, d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) <= int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) <= int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq16U (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint16(c) <= uint16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint16(c) <= uint16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) <= int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) <= int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq32U (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint32(c) <= uint32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint32(c) <= uint32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) <= int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) <= int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq64U (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint64(c) <= uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint64(c) <= uint64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) <= int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) <= int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Leq8U (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint8(c) <= uint8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint8(c) <= uint8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) < int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) < int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less16U (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint16(c) < uint16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint16(c) < uint16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) < int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) < int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less32U (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint32(c) < uint32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint32(c) < uint32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) < int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) < int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less64U (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint64(c) < uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint64(c) < uint64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) < int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) < int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Less8U (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(uint8(c) < uint8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(uint8(c) < uint8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Load <t1> p1 (Store [w] p2 x _))
+ // cond: isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && w == t1.Size()
+ // result: x
+ for {
+ t1 := v.Type
+ p1 := v.Args[0]
+ if v.Args[1].Op != OpStore {
+ break
+ }
+ w := v.Args[1].AuxInt
+ p2 := v.Args[1].Args[0]
+ x := v.Args[1].Args[1]
+ if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == CMPeq && w == t1.Size()) {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Load <t> _ _)
+ // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)
+ // result: (StructMake0)
+ for {
+ t := v.Type
+ if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake0)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)
+ // result: (StructMake1 (Load <t.FieldType(0)> ptr mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake1)
+ v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)
+ // result: (StructMake2 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake2)
+ v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, t.FieldType(1))
+ v2 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v2.AuxInt = t.FieldOff(1)
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)
+ // result: (StructMake3 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake3)
+ v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, t.FieldType(1))
+ v2 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v2.AuxInt = t.FieldOff(1)
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpLoad, t.FieldType(2))
+ v4 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(2).PtrTo())
+ v4.AuxInt = t.FieldOff(2)
+ v4.AddArg(ptr)
+ v3.AddArg(v4)
+ v3.AddArg(mem)
+ v.AddArg(v3)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)
+ // result: (StructMake4 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpStructMake4)
+ v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, t.FieldType(1))
+ v2 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v2.AuxInt = t.FieldOff(1)
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpLoad, t.FieldType(2))
+ v4 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(2).PtrTo())
+ v4.AuxInt = t.FieldOff(2)
+ v4.AddArg(ptr)
+ v3.AddArg(v4)
+ v3.AddArg(mem)
+ v.AddArg(v3)
+ v5 := b.NewValue0(v.Line, OpLoad, t.FieldType(3))
+ v6 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(3).PtrTo())
+ v6.AuxInt = t.FieldOff(3)
+ v6.AddArg(ptr)
+ v5.AddArg(v6)
+ v5.AddArg(mem)
+ v.AddArg(v5)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsComplex() && t.Size() == 8
+ // result: (ComplexMake (Load <config.fe.TypeFloat32()> ptr mem) (Load <config.fe.TypeFloat32()> (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr) mem) )
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsComplex() && t.Size() == 8) {
+ break
+ }
+ v.reset(OpComplexMake)
+ v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32())
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32())
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat32().PtrTo())
+ v2.AuxInt = 4
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsComplex() && t.Size() == 16
+ // result: (ComplexMake (Load <config.fe.TypeFloat64()> ptr mem) (Load <config.fe.TypeFloat64()> (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr) mem) )
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsComplex() && t.Size() == 16) {
+ break
+ }
+ v.reset(OpComplexMake)
+ v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64())
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64())
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat64().PtrTo())
+ v2.AuxInt = 8
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsString()
+ // result: (StringMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsString()) {
+ break
+ }
+ v.reset(OpStringMake)
+ v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, config.fe.TypeInt())
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v2.AuxInt = config.PtrSize
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsSlice()
+ // result: (SliceMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsSlice()) {
+ break
+ }
+ v.reset(OpSliceMake)
+ v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, config.fe.TypeInt())
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v2.AuxInt = config.PtrSize
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpLoad, config.fe.TypeInt())
+ v4 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v4.AuxInt = 2 * config.PtrSize
+ v4.AddArg(ptr)
+ v3.AddArg(v4)
+ v3.AddArg(mem)
+ v.AddArg(v3)
+ return true
+ }
+ // match: (Load <t> ptr mem)
+ // cond: t.IsInterface()
+ // result: (IMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeBytePtr()> (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ mem := v.Args[1]
+ if !(t.IsInterface()) {
+ break
+ }
+ v.reset(OpIMake)
+ v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
+ v0.AddArg(ptr)
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeBytePtr().PtrTo())
+ v2.AuxInt = config.PtrSize
+ v2.AddArg(ptr)
+ v1.AddArg(v2)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const16 [int64(int16(c) << uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = int64(int16(c) << uint64(d))
+ return true
+ }
+ // match: (Lsh16x64 (Const16 [0]) _)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh16x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Lsh16x64 _ (Const64 [c]))
+ // cond: uint64(c) >= 16
+ // result: (Const16 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 16) {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Lsh16x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpLsh16x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpLsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh16x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const32 [int64(int32(c) << uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = int64(int32(c) << uint64(d))
+ return true
+ }
+ // match: (Lsh32x64 (Const32 [0]) _)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh32x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Lsh32x64 _ (Const64 [c]))
+ // cond: uint64(c) >= 32
+ // result: (Const32 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 32) {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Lsh32x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpLsh32x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpLsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh32x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Lsh64x16 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Lsh64x32 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [c << uint64(d)])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = c << uint64(d)
+ return true
+ }
+ // match: (Lsh64x64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh64x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Lsh64x64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh64x64 _ (Const64 [c]))
+ // cond: uint64(c) >= 64
+ // result: (Const64 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 64) {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Lsh64x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpLsh64x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpLsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh64x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Lsh64x8 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const8 [int64(int8(c) << uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(int8(c) << uint64(d))
+ return true
+ }
+ // match: (Lsh8x64 (Const8 [0]) _)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh8x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Lsh8x64 _ (Const64 [c]))
+ // cond: uint64(c) >= 8
+ // result: (Const8 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 8) {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Lsh8x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpLsh8x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpLsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Lsh8x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpLsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMod64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod64 <t> x (Const64 [c]))
+ // cond: smagic64ok(c)
+ // result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(smagic64ok(c)) {
+ break
+ }
+ v.reset(OpSub64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpMul64, t)
+ v1 := b.NewValue0(v.Line, OpDiv64, t)
+ v1.AddArg(x)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = c
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = c
+ v0.AddArg(v3)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMod64u(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mod64u <t> x (Const64 [c]))
+ // cond: umagic64ok(c)
+ // result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c])))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(umagic64ok(c)) {
+ break
+ }
+ v.reset(OpSub64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpMul64, t)
+ v1 := b.NewValue0(v.Line, OpDiv64u, t)
+ v1.AddArg(x)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = c
+ v1.AddArg(v2)
+ v0.AddArg(v1)
+ v3 := b.NewValue0(v.Line, OpConst64, t)
+ v3.AuxInt = c
+ v0.AddArg(v3)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (Const16 [c*d])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = c * d
+ return true
+ }
+ // match: (Mul16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Mul16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpMul16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Mul16 (Const16 [0]) _)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (Const32 [c*d])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = c * d
+ return true
+ }
+ // match: (Mul32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Mul32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpMul32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
+ // cond:
+ // result: (Add32 (Const32 <t> [c*d]) (Mul32 <t> (Const32 <t> [c]) x))
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd32 {
+ break
+ }
+ if v.Args[1].Type != v.Args[0].Type {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpAdd32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c * d
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpMul32, t)
+ v2 := b.NewValue0(v.Line, OpConst32, t)
+ v2.AuxInt = c
+ v1.AddArg(v2)
+ v1.AddArg(x)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Mul32 (Const32 [0]) _)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [c*d])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = c * d
+ return true
+ }
+ // match: (Mul64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Mul64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpMul64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
+ // cond:
+ // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd64 {
+ break
+ }
+ if v.Args[1].Type != v.Args[0].Type {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpAdd64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c * d
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpMul64, t)
+ v2 := b.NewValue0(v.Line, OpConst64, t)
+ v2.AuxInt = c
+ v1.AddArg(v2)
+ v1.AddArg(x)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Mul64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Mul8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (Const8 [c*d])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = c * d
+ return true
+ }
+ // match: (Mul8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Mul8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpMul8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Mul8 (Const8 [0]) _)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeg16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg16 (Const16 [c]))
+ // cond:
+ // result: (Const16 [-c])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = -c
+ return true
+ }
+ // match: (Neg16 (Sub16 x y))
+ // cond:
+ // result: (Sub16 y x)
+ for {
+ if v.Args[0].Op != OpSub16 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpSub16)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeg32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg32 (Const32 [c]))
+ // cond:
+ // result: (Const32 [-c])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = -c
+ return true
+ }
+ // match: (Neg32 (Sub32 x y))
+ // cond:
+ // result: (Sub32 y x)
+ for {
+ if v.Args[0].Op != OpSub32 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpSub32)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeg64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg64 (Const64 [c]))
+ // cond:
+ // result: (Const64 [-c])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = -c
+ return true
+ }
+ // match: (Neg64 (Sub64 x y))
+ // cond:
+ // result: (Sub64 y x)
+ for {
+ if v.Args[0].Op != OpSub64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpSub64)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeg8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neg8 (Const8 [c]))
+ // cond:
+ // result: (Const8 [-c])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = -c
+ return true
+ }
+ // match: (Neg8 (Sub8 x y))
+ // cond:
+ // result: (Sub8 y x)
+ for {
+ if v.Args[0].Op != OpSub8 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ v.reset(OpSub8)
+ v.AddArg(y)
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq16 x x)
+ // cond:
+ // result: (ConstBool [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
+ // cond:
+ // result: (Neq16 (Const16 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd16 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpNeq16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Neq16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpNeq16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int16(c) != int16(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int16(c) != int16(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq32 x x)
+ // cond:
+ // result: (ConstBool [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
+ // cond:
+ // result: (Neq32 (Const32 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd32 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpNeq32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Neq32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpNeq32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int32(c) != int32(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int32(c) != int32(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq64 x x)
+ // cond:
+ // result: (ConstBool [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
+ // cond:
+ // result: (Neq64 (Const64 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd64 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpNeq64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Neq64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpNeq64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int64(c) != int64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int64(c) != int64(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Neq8 x x)
+ // cond:
+ // result: (ConstBool [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConstBool)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Neq8 (ConstBool [c]) (ConstBool [d]))
+ // cond:
+ // result: (ConstBool [b2i((int8(c) != 0) != (int8(d) != 0))])
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConstBool {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i((int8(c) != 0) != (int8(d) != 0))
+ return true
+ }
+ // match: (Neq8 (ConstBool [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq8 (ConstBool [1]) x)
+ // cond:
+ // result: (Not x)
+ for {
+ if v.Args[0].Op != OpConstBool {
+ break
+ }
+ if v.Args[0].AuxInt != 1 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpNot)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
+ // cond:
+ // result: (Neq8 (Const8 <t> [c-d]) x)
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ t := v.Args[0].Type
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpAdd8 {
+ break
+ }
+ if v.Args[1].Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[1].Args[0].Type != v.Args[0].Type {
+ break
+ }
+ d := v.Args[1].Args[0].AuxInt
+ x := v.Args[1].Args[1]
+ v.reset(OpNeq8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c - d
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Neq8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpNeq8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq8 x (ConstBool <t> [c]))
+ // cond: x.Op != OpConstBool
+ // result: (Neq8 (ConstBool <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConstBool {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConstBool) {
+ break
+ }
+ v.reset(OpNeq8)
+ v0 := b.NewValue0(v.Line, OpConstBool, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Neq8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (ConstBool [b2i(int8(c) != int8(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConstBool)
+ v.AuxInt = b2i(int8(c) != int8(d))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NeqInter x y)
+ // cond:
+ // result: (NeqPtr (ITab x) (ITab y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpNeqPtr)
+ v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NeqPtr p (ConstNil))
+ // cond:
+ // result: (IsNonNil p)
+ for {
+ p := v.Args[0]
+ if v.Args[1].Op != OpConstNil {
+ break
+ }
+ v.reset(OpIsNonNil)
+ v.AddArg(p)
+ return true
+ }
+ // match: (NeqPtr (ConstNil) p)
+ // cond:
+ // result: (IsNonNil p)
+ for {
+ if v.Args[0].Op != OpConstNil {
+ break
+ }
+ p := v.Args[1]
+ v.reset(OpIsNonNil)
+ v.AddArg(p)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (NeqSlice x y)
+ // cond:
+ // result: (NeqPtr (SlicePtr x) (SlicePtr y))
+ for {
+ x := v.Args[0]
+ y := v.Args[1]
+ v.reset(OpNeqPtr)
+ v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr())
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr())
+ v1.AddArg(y)
+ v.AddArg(v1)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Or16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpOr16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or16 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or16 (Const16 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or16 (Const16 [-1]) _)
+ // cond:
+ // result: (Const16 [-1])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = -1
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Or32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpOr32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or32 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or32 (Const32 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or32 (Const32 [-1]) _)
+ // cond:
+ // result: (Const32 [-1])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = -1
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Or64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpOr64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or64 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or64 (Const64 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or64 (Const64 [-1]) _)
+ // cond:
+ // result: (Const64 [-1])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = -1
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Or8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Or8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpOr8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or8 x x)
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or8 (Const8 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Or8 (Const8 [-1]) _)
+ // cond:
+ // result: (Const8 [-1])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != -1 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = -1
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpPhi(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Phi (Const8 [c]) (Const8 [d]))
+ // cond: int8(c) == int8(d)
+ // result: (Const8 [c])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if len(v.Args) != 2 {
+ break
+ }
+ if !(int8(c) == int8(d)) {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = c
+ return true
+ }
+ // match: (Phi (Const16 [c]) (Const16 [d]))
+ // cond: int16(c) == int16(d)
+ // result: (Const16 [c])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if len(v.Args) != 2 {
+ break
+ }
+ if !(int16(c) == int16(d)) {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = c
+ return true
+ }
+ // match: (Phi (Const32 [c]) (Const32 [d]))
+ // cond: int32(c) == int32(d)
+ // result: (Const32 [c])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if len(v.Args) != 2 {
+ break
+ }
+ if !(int32(c) == int32(d)) {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = c
+ return true
+ }
+ // match: (Phi (Const64 [c]) (Const64 [c]))
+ // cond:
+ // result: (Const64 [c])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != v.Args[0].AuxInt {
+ break
+ }
+ if len(v.Args) != 2 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = c
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (PtrIndex <t> ptr idx)
+ // cond: config.PtrSize == 4
+ // result: (AddPtr ptr (Mul32 <config.fe.TypeInt()> idx (Const32 <config.fe.TypeInt()> [t.Elem().Size()])))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ idx := v.Args[1]
+ if !(config.PtrSize == 4) {
+ break
+ }
+ v.reset(OpAddPtr)
+ v.AddArg(ptr)
+ v0 := b.NewValue0(v.Line, OpMul32, config.fe.TypeInt())
+ v0.AddArg(idx)
+ v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt())
+ v1.AuxInt = t.Elem().Size()
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ // match: (PtrIndex <t> ptr idx)
+ // cond: config.PtrSize == 8
+ // result: (AddPtr ptr (Mul64 <config.fe.TypeInt()> idx (Const64 <config.fe.TypeInt()> [t.Elem().Size()])))
+ for {
+ t := v.Type
+ ptr := v.Args[0]
+ idx := v.Args[1]
+ if !(config.PtrSize == 8) {
+ break
+ }
+ v.reset(OpAddPtr)
+ v.AddArg(ptr)
+ v0 := b.NewValue0(v.Line, OpMul64, config.fe.TypeInt())
+ v0.AddArg(idx)
+ v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt())
+ v1.AuxInt = t.Elem().Size()
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const16 [int64(uint16(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = int64(uint16(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh16Ux64 (Const16 [0]) _)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh16Ux64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh16Ux64 _ (Const64 [c]))
+ // cond: uint64(c) >= 16
+ // result: (Const16 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 16) {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh16Ux64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh16Ux64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh16Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16Ux8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const16 [int64(int16(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = int64(int16(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh16x64 (Const16 [0]) _)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh16x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh16x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh16x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh16x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh16x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const32 [int64(uint32(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = int64(uint32(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh32Ux64 (Const32 [0]) _)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh32Ux64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh32Ux64 _ (Const64 [c]))
+ // cond: uint64(c) >= 32
+ // result: (Const32 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 32) {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh32Ux64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh32Ux64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh32Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32Ux8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const32 [int64(int32(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = int64(int32(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh32x64 (Const32 [0]) _)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh32x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh32x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh32x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh32x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh32x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64Ux16 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64Ux32 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [int64(uint64(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = int64(uint64(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh64Ux64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh64Ux64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh64Ux64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh64Ux64 _ (Const64 [c]))
+ // cond: uint64(c) >= 64
+ // result: (Const64 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 64) {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh64Ux64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh64Ux64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh64Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64Ux8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64Ux8 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64x16 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64x32 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [c >> uint64(d)])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = c >> uint64(d)
+ return true
+ }
+ // match: (Rsh64x64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh64x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh64x64 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh64x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh64x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh64x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh64x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ // match: (Rsh64x8 (Const64 [0]) _)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const8 [int64(uint8(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(uint8(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh8Ux64 (Const8 [0]) _)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh8Ux64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh8Ux64 _ (Const64 [c]))
+ // cond: uint64(c) >= 8
+ // result: (Const8 [0])
+ for {
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ if !(uint64(c) >= 8) {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh8Ux64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh8Ux64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh8Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8Ux8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8Ux64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x16 <t> x (Const16 [c]))
+ // cond:
+ // result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint16(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x32 <t> x (Const32 [c]))
+ // cond:
+ // result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint32(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const8 [int64(int8(c) >> uint64(d))])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(int8(c) >> uint64(d))
+ return true
+ }
+ // match: (Rsh8x64 (Const8 [0]) _)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Rsh8x64 x (Const64 [0]))
+ // cond:
+ // result: x
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ if v.Args[1].AuxInt != 0 {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d]))
+ // cond: !uaddOvf(c,d)
+ // result: (Rsh8x64 x (Const64 <t> [c+d]))
+ for {
+ t := v.Type
+ if v.Args[0].Op != OpRsh8x64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ if v.Args[0].Args[1].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].Args[1].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ if !(!uaddOvf(c, d)) {
+ break
+ }
+ v.reset(OpRsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c + d
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Rsh8x8 <t> x (Const8 [c]))
+ // cond:
+ // result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))]))
+ for {
+ t := v.Type
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ c := v.Args[1].AuxInt
+ v.reset(OpRsh8x64)
+ v.AddArg(x)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = int64(uint8(c))
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SliceCap (SliceMake _ _ cap))
+ // cond:
+ // result: cap
+ for {
+ if v.Args[0].Op != OpSliceMake {
+ break
+ }
+ cap := v.Args[0].Args[2]
+ v.reset(OpCopy)
+ v.Type = cap.Type
+ v.AddArg(cap)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SliceLen (SliceMake _ len _))
+ // cond:
+ // result: len
+ for {
+ if v.Args[0].Op != OpSliceMake {
+ break
+ }
+ len := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = len.Type
+ v.AddArg(len)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (SlicePtr (SliceMake ptr _ _ ))
+ // cond:
+ // result: ptr
+ for {
+ if v.Args[0].Op != OpSliceMake {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = ptr.Type
+ v.AddArg(ptr)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpStore(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Store _ (StructMake0) mem)
+ // cond:
+ // result: mem
+ for {
+ if v.Args[1].Op != OpStructMake0 {
+ break
+ }
+ mem := v.Args[2]
+ v.reset(OpCopy)
+ v.Type = mem.Type
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store dst (StructMake1 <t> f0) mem)
+ // cond:
+ // result: (Store [t.FieldType(0).Size()] dst f0 mem)
+ for {
+ dst := v.Args[0]
+ if v.Args[1].Op != OpStructMake1 {
+ break
+ }
+ t := v.Args[1].Type
+ f0 := v.Args[1].Args[0]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = t.FieldType(0).Size()
+ v.AddArg(dst)
+ v.AddArg(f0)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store dst (StructMake2 <t> f0 f1) mem)
+ // cond:
+ // result: (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))
+ for {
+ dst := v.Args[0]
+ if v.Args[1].Op != OpStructMake2 {
+ break
+ }
+ t := v.Args[1].Type
+ f0 := v.Args[1].Args[0]
+ f1 := v.Args[1].Args[1]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = t.FieldType(1).Size()
+ v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v0.AuxInt = t.FieldOff(1)
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(f1)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = t.FieldType(0).Size()
+ v1.AddArg(dst)
+ v1.AddArg(f0)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
+ // cond:
+ // result: (Store [t.FieldType(2).Size()] (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)))
+ for {
+ dst := v.Args[0]
+ if v.Args[1].Op != OpStructMake3 {
+ break
+ }
+ t := v.Args[1].Type
+ f0 := v.Args[1].Args[0]
+ f1 := v.Args[1].Args[1]
+ f2 := v.Args[1].Args[2]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = t.FieldType(2).Size()
+ v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(2).PtrTo())
+ v0.AuxInt = t.FieldOff(2)
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(f2)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = t.FieldType(1).Size()
+ v2 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v2.AuxInt = t.FieldOff(1)
+ v2.AddArg(dst)
+ v1.AddArg(v2)
+ v1.AddArg(f1)
+ v3 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v3.AuxInt = t.FieldType(0).Size()
+ v3.AddArg(dst)
+ v3.AddArg(f0)
+ v3.AddArg(mem)
+ v1.AddArg(v3)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
+ // cond:
+ // result: (Store [t.FieldType(3).Size()] (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store [t.FieldType(2).Size()] (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))))
+ for {
+ dst := v.Args[0]
+ if v.Args[1].Op != OpStructMake4 {
+ break
+ }
+ t := v.Args[1].Type
+ f0 := v.Args[1].Args[0]
+ f1 := v.Args[1].Args[1]
+ f2 := v.Args[1].Args[2]
+ f3 := v.Args[1].Args[3]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = t.FieldType(3).Size()
+ v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(3).PtrTo())
+ v0.AuxInt = t.FieldOff(3)
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(f3)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = t.FieldType(2).Size()
+ v2 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(2).PtrTo())
+ v2.AuxInt = t.FieldOff(2)
+ v2.AddArg(dst)
+ v1.AddArg(v2)
+ v1.AddArg(f2)
+ v3 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v3.AuxInt = t.FieldType(1).Size()
+ v4 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo())
+ v4.AuxInt = t.FieldOff(1)
+ v4.AddArg(dst)
+ v3.AddArg(v4)
+ v3.AddArg(f1)
+ v5 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v5.AuxInt = t.FieldType(0).Size()
+ v5.AddArg(dst)
+ v5.AddArg(f0)
+ v5.AddArg(mem)
+ v3.AddArg(v5)
+ v1.AddArg(v3)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [8] dst (ComplexMake real imag) mem)
+ // cond:
+ // result: (Store [4] (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) imag (Store [4] dst real mem))
+ for {
+ if v.AuxInt != 8 {
+ break
+ }
+ dst := v.Args[0]
+ if v.Args[1].Op != OpComplexMake {
+ break
+ }
+ real := v.Args[1].Args[0]
+ imag := v.Args[1].Args[1]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = 4
+ v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat32().PtrTo())
+ v0.AuxInt = 4
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(imag)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = 4
+ v1.AddArg(dst)
+ v1.AddArg(real)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [16] dst (ComplexMake real imag) mem)
+ // cond:
+ // result: (Store [8] (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) imag (Store [8] dst real mem))
+ for {
+ if v.AuxInt != 16 {
+ break
+ }
+ dst := v.Args[0]
+ if v.Args[1].Op != OpComplexMake {
+ break
+ }
+ real := v.Args[1].Args[0]
+ imag := v.Args[1].Args[1]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = 8
+ v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat64().PtrTo())
+ v0.AuxInt = 8
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(imag)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = 8
+ v1.AddArg(dst)
+ v1.AddArg(real)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem)
+ // cond:
+ // result: (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))
+ for {
+ if v.AuxInt != 2*config.PtrSize {
+ break
+ }
+ dst := v.Args[0]
+ if v.Args[1].Op != OpStringMake {
+ break
+ }
+ ptr := v.Args[1].Args[0]
+ len := v.Args[1].Args[1]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = config.PtrSize
+ v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v0.AuxInt = config.PtrSize
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(len)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = config.PtrSize
+ v1.AddArg(dst)
+ v1.AddArg(ptr)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem)
+ // cond:
+ // result: (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)))
+ for {
+ if v.AuxInt != 3*config.PtrSize {
+ break
+ }
+ dst := v.Args[0]
+ if v.Args[1].Op != OpSliceMake {
+ break
+ }
+ ptr := v.Args[1].Args[0]
+ len := v.Args[1].Args[1]
+ cap := v.Args[1].Args[2]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = config.PtrSize
+ v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v0.AuxInt = 2 * config.PtrSize
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(cap)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = config.PtrSize
+ v2 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo())
+ v2.AuxInt = config.PtrSize
+ v2.AddArg(dst)
+ v1.AddArg(v2)
+ v1.AddArg(len)
+ v3 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v3.AuxInt = config.PtrSize
+ v3.AddArg(dst)
+ v3.AddArg(ptr)
+ v3.AddArg(mem)
+ v1.AddArg(v3)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [2*config.PtrSize] dst (IMake itab data) mem)
+ // cond:
+ // result: (Store [config.PtrSize] (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem))
+ for {
+ if v.AuxInt != 2*config.PtrSize {
+ break
+ }
+ dst := v.Args[0]
+ if v.Args[1].Op != OpIMake {
+ break
+ }
+ itab := v.Args[1].Args[0]
+ data := v.Args[1].Args[1]
+ mem := v.Args[2]
+ v.reset(OpStore)
+ v.AuxInt = config.PtrSize
+ v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeBytePtr().PtrTo())
+ v0.AuxInt = config.PtrSize
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v.AddArg(data)
+ v1 := b.NewValue0(v.Line, OpStore, TypeMem)
+ v1.AuxInt = config.PtrSize
+ v1.AddArg(dst)
+ v1.AddArg(itab)
+ v1.AddArg(mem)
+ v.AddArg(v1)
+ return true
+ }
+ // match: (Store [size] dst (Load <t> src mem) mem)
+ // cond: !config.fe.CanSSA(t)
+ // result: (Move [size] dst src mem)
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ if v.Args[1].Op != OpLoad {
+ break
+ }
+ t := v.Args[1].Type
+ src := v.Args[1].Args[0]
+ mem := v.Args[1].Args[1]
+ if v.Args[2] != mem {
+ break
+ }
+ if !(!config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpMove)
+ v.AuxInt = size
+ v.AddArg(dst)
+ v.AddArg(src)
+ v.AddArg(mem)
+ return true
+ }
+ // match: (Store [size] dst (Load <t> src mem) (VarDef {x} mem))
+ // cond: !config.fe.CanSSA(t)
+ // result: (Move [size] dst src (VarDef {x} mem))
+ for {
+ size := v.AuxInt
+ dst := v.Args[0]
+ if v.Args[1].Op != OpLoad {
+ break
+ }
+ t := v.Args[1].Type
+ src := v.Args[1].Args[0]
+ mem := v.Args[1].Args[1]
+ if v.Args[2].Op != OpVarDef {
+ break
+ }
+ x := v.Args[2].Aux
+ if v.Args[2].Args[0] != mem {
+ break
+ }
+ if !(!config.fe.CanSSA(t)) {
+ break
+ }
+ v.reset(OpMove)
+ v.AuxInt = size
+ v.AddArg(dst)
+ v.AddArg(src)
+ v0 := b.NewValue0(v.Line, OpVarDef, TypeMem)
+ v0.Aux = x
+ v0.AddArg(mem)
+ v.AddArg(v0)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (StringLen (StringMake _ len))
+ // cond:
+ // result: len
+ for {
+ if v.Args[0].Op != OpStringMake {
+ break
+ }
+ len := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = len.Type
+ v.AddArg(len)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (StringPtr (StringMake ptr _))
+ // cond:
+ // result: ptr
+ for {
+ if v.Args[0].Op != OpStringMake {
+ break
+ }
+ ptr := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = ptr.Type
+ v.AddArg(ptr)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (StructSelect (StructMake1 x))
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpStructMake1 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [0] (StructMake2 x _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake2 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [1] (StructMake2 _ x))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake2 {
+ break
+ }
+ x := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [0] (StructMake3 x _ _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake3 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [1] (StructMake3 _ x _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake3 {
+ break
+ }
+ x := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [2] (StructMake3 _ _ x))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 2 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake3 {
+ break
+ }
+ x := v.Args[0].Args[2]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [0] (StructMake4 x _ _ _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 0 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake4 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [1] (StructMake4 _ x _ _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 1 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake4 {
+ break
+ }
+ x := v.Args[0].Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [2] (StructMake4 _ _ x _))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 2 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake4 {
+ break
+ }
+ x := v.Args[0].Args[2]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [3] (StructMake4 _ _ _ x))
+ // cond:
+ // result: x
+ for {
+ if v.AuxInt != 3 {
+ break
+ }
+ if v.Args[0].Op != OpStructMake4 {
+ break
+ }
+ x := v.Args[0].Args[3]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ // match: (StructSelect [i] (Load <t> ptr mem))
+ // cond: !config.fe.CanSSA(t)
+ // result: @v.Args[0].Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(i)] ptr) mem)
+ for {
+ i := v.AuxInt
+ if v.Args[0].Op != OpLoad {
+ break
+ }
+ t := v.Args[0].Type
+ ptr := v.Args[0].Args[0]
+ mem := v.Args[0].Args[1]
+ if !(!config.fe.CanSSA(t)) {
+ break
+ }
+ b = v.Args[0].Block
+ v0 := b.NewValue0(v.Line, OpLoad, v.Type)
+ v.reset(OpCopy)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Line, OpOffPtr, v.Type.PtrTo())
+ v.reset(OpCopy)
+ v.AddArg(v1)
+ v1.AuxInt = t.FieldOff(i)
+ v1.AddArg(ptr)
+ v0.AddArg(v1)
+ v0.AddArg(mem)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub16 (Const16 [c]) (Const16 [d]))
+ // cond:
+ // result: (Const16 [c-d])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = c - d
+ return true
+ }
+ // match: (Sub16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Add16 (Const16 <t> [-c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpAdd16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = -c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Sub16 x x)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Sub16 (Add16 x y) x)
+ // cond:
+ // result: y
+ for {
+ if v.Args[0].Op != OpAdd16 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = y.Type
+ v.AddArg(y)
+ return true
+ }
+ // match: (Sub16 (Add16 x y) y)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpAdd16 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != y {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub32 (Const32 [c]) (Const32 [d]))
+ // cond:
+ // result: (Const32 [c-d])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = c - d
+ return true
+ }
+ // match: (Sub32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Add32 (Const32 <t> [-c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpAdd32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = -c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Sub32 x x)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Sub32 (Add32 x y) x)
+ // cond:
+ // result: y
+ for {
+ if v.Args[0].Op != OpAdd32 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = y.Type
+ v.AddArg(y)
+ return true
+ }
+ // match: (Sub32 (Add32 x y) y)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpAdd32 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != y {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub64 (Const64 [c]) (Const64 [d]))
+ // cond:
+ // result: (Const64 [c-d])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst64)
+ v.AuxInt = c - d
+ return true
+ }
+ // match: (Sub64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Add64 (Const64 <t> [-c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpAdd64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = -c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Sub64 x x)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Sub64 (Add64 x y) x)
+ // cond:
+ // result: y
+ for {
+ if v.Args[0].Op != OpAdd64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = y.Type
+ v.AddArg(y)
+ return true
+ }
+ // match: (Sub64 (Add64 x y) y)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpAdd64 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != y {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Sub8 (Const8 [c]) (Const8 [d]))
+ // cond:
+ // result: (Const8 [c-d])
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ d := v.Args[1].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = c - d
+ return true
+ }
+ // match: (Sub8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Add8 (Const8 <t> [-c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpAdd8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = -c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Sub8 x x)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Sub8 (Add8 x y) x)
+ // cond:
+ // result: y
+ for {
+ if v.Args[0].Op != OpAdd8 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = y.Type
+ v.AddArg(y)
+ return true
+ }
+ // match: (Sub8 (Add8 x y) y)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpAdd8 {
+ break
+ }
+ x := v.Args[0].Args[0]
+ y := v.Args[0].Args[1]
+ if v.Args[1] != y {
+ break
+ }
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc16to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc16to8 (Const16 [c]))
+ // cond:
+ // result: (Const8 [int64(int8(c))])
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(int8(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc32to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc32to16 (Const32 [c]))
+ // cond:
+ // result: (Const16 [int64(int16(c))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = int64(int16(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc32to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc32to8 (Const32 [c]))
+ // cond:
+ // result: (Const8 [int64(int8(c))])
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(int8(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc64to16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to16 (Const64 [c]))
+ // cond:
+ // result: (Const16 [int64(int16(c))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst16)
+ v.AuxInt = int64(int16(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc64to32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to32 (Const64 [c]))
+ // cond:
+ // result: (Const32 [int64(int32(c))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst32)
+ v.AuxInt = int64(int32(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpTrunc64to8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Trunc64to8 (Const64 [c]))
+ // cond:
+ // result: (Const8 [int64(int8(c))])
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ c := v.Args[0].AuxInt
+ v.reset(OpConst8)
+ v.AuxInt = int64(int8(c))
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor16 x (Const16 <t> [c]))
+ // cond: x.Op != OpConst16
+ // result: (Xor16 (Const16 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst16 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst16) {
+ break
+ }
+ v.reset(OpXor16)
+ v0 := b.NewValue0(v.Line, OpConst16, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Xor16 x x)
+ // cond:
+ // result: (Const16 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst16)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Xor16 (Const16 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst16 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor32 x (Const32 <t> [c]))
+ // cond: x.Op != OpConst32
+ // result: (Xor32 (Const32 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst32 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst32) {
+ break
+ }
+ v.reset(OpXor32)
+ v0 := b.NewValue0(v.Line, OpConst32, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Xor32 x x)
+ // cond:
+ // result: (Const32 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst32)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Xor32 (Const32 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst32 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor64 x (Const64 <t> [c]))
+ // cond: x.Op != OpConst64
+ // result: (Xor64 (Const64 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst64 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst64) {
+ break
+ }
+ v.reset(OpXor64)
+ v0 := b.NewValue0(v.Line, OpConst64, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Xor64 x x)
+ // cond:
+ // result: (Const64 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst64)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Xor64 (Const64 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst64 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool {
+ b := v.Block
+ _ = b
+ // match: (Xor8 x (Const8 <t> [c]))
+ // cond: x.Op != OpConst8
+ // result: (Xor8 (Const8 <t> [c]) x)
+ for {
+ x := v.Args[0]
+ if v.Args[1].Op != OpConst8 {
+ break
+ }
+ t := v.Args[1].Type
+ c := v.Args[1].AuxInt
+ if !(x.Op != OpConst8) {
+ break
+ }
+ v.reset(OpXor8)
+ v0 := b.NewValue0(v.Line, OpConst8, t)
+ v0.AuxInt = c
+ v.AddArg(v0)
+ v.AddArg(x)
+ return true
+ }
+ // match: (Xor8 x x)
+ // cond:
+ // result: (Const8 [0])
+ for {
+ x := v.Args[0]
+ if v.Args[1] != x {
+ break
+ }
+ v.reset(OpConst8)
+ v.AuxInt = 0
+ return true
+ }
+ // match: (Xor8 (Const8 [0]) x)
+ // cond:
+ // result: x
+ for {
+ if v.Args[0].Op != OpConst8 {
+ break
+ }
+ if v.Args[0].AuxInt != 0 {
+ break
+ }
+ x := v.Args[1]
+ v.reset(OpCopy)
+ v.Type = x.Type
+ v.AddArg(x)
+ return true
+ }
+ return false
+}
+func rewriteBlockgeneric(b *Block) bool {
+ switch b.Kind {
+ case BlockCheck:
+ // match: (Check (NilCheck (GetG _) _) next)
+ // cond:
+ // result: (Plain nil next)
+ for {
+ v := b.Control
+ if v.Op != OpNilCheck {
+ break
+ }
+ if v.Args[0].Op != OpGetG {
+ break
+ }
+ next := b.Succs[0]
+ b.Kind = BlockPlain
+ b.Control = nil
+ b.Succs[0] = next
+ b.Likely = BranchUnknown
+ return true
+ }
+ case BlockIf:
+ // match: (If (Not cond) yes no)
+ // cond:
+ // result: (If cond no yes)
+ for {
+ v := b.Control
+ if v.Op != OpNot {
+ break
+ }
+ cond := v.Args[0]
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ b.Kind = BlockIf
+ b.Control = cond
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ // match: (If (ConstBool [c]) yes no)
+ // cond: c == 1
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpConstBool {
+ break
+ }
+ c := v.AuxInt
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ if !(c == 1) {
+ break
+ }
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = yes
+ b.Succs[1] = no
+ return true
+ }
+ // match: (If (ConstBool [c]) yes no)
+ // cond: c == 0
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpConstBool {
+ break
+ }
+ c := v.AuxInt
+ yes := b.Succs[0]
+ no := b.Succs[1]
+ if !(c == 0) {
+ break
+ }
+ b.Kind = BlockFirst
+ b.Control = nil
+ b.Succs[0] = no
+ b.Succs[1] = yes
+ b.Likely *= -1
+ return true
+ }
+ }
+ return false
+}
diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go
new file mode 100644
index 0000000..dd0a42a
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/schedule.go
@@ -0,0 +1,195 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+const (
+ ScorePhi = iota // towards top of block
+ ScoreVarDef
+ ScoreMemory
+ ScoreDefault
+ ScoreFlags
+ ScoreControl // towards bottom of block
+
+ ScoreCount // not a real score
+)
+
+// Schedule the Values in each Block. After this phase returns, the
+// order of b.Values matters and is the order in which those values
+// will appear in the assembly output. For now it generates a
+// reasonable valid schedule using a priority queue. TODO(khr):
+// schedule smarter.
+func schedule(f *Func) {
+ // For each value, the number of times it is used in the block
+ // by values that have not been scheduled yet.
+ uses := make([]int, f.NumValues())
+
+ // "priority" for a value
+ score := make([]uint8, f.NumValues())
+
+ // scheduling order. We queue values in this list in reverse order.
+ var order []*Value
+
+ // priority queue of legally schedulable (0 unscheduled uses) values
+ var priq [ScoreCount][]*Value
+
+ // maps mem values to the next live memory value
+ nextMem := make([]*Value, f.NumValues())
+ // additional pretend arguments for each Value. Used to enforce load/store ordering.
+ additionalArgs := make([][]*Value, f.NumValues())
+
+ for _, b := range f.Blocks {
+ // Find store chain for block.
+ // Store chains for different blocks overwrite each other, so
+ // the calculated store chain is good only for this block.
+ for _, v := range b.Values {
+ if v.Op != OpPhi && v.Type.IsMemory() {
+ for _, w := range v.Args {
+ if w.Type.IsMemory() {
+ nextMem[w.ID] = v
+ }
+ }
+ }
+ }
+
+ // Compute uses.
+ for _, v := range b.Values {
+ if v.Op == OpPhi {
+ // If a value is used by a phi, it does not induce
+ // a scheduling edge because that use is from the
+ // previous iteration.
+ continue
+ }
+ for _, w := range v.Args {
+ if w.Block == b {
+ uses[w.ID]++
+ }
+ // Any load must come before the following store.
+ if v.Type.IsMemory() || !w.Type.IsMemory() {
+ continue // not a load
+ }
+ s := nextMem[w.ID]
+ if s == nil || s.Block != b {
+ continue
+ }
+ additionalArgs[s.ID] = append(additionalArgs[s.ID], v)
+ uses[v.ID]++
+ }
+ }
+ // Compute score. Larger numbers are scheduled closer to the end of the block.
+ for _, v := range b.Values {
+ switch {
+ case v.Op == OpAMD64LoweredGetClosurePtr:
+ // We also score GetLoweredClosurePtr as early as possible to ensure that the
+ // context register is not stomped. GetLoweredClosurePtr should only appear
+ // in the entry block where there are no phi functions, so there is no
+ // conflict or ambiguity here.
+ if b != f.Entry {
+ f.Fatalf("LoweredGetClosurePtr appeared outside of entry block, b=%s", b.String())
+ }
+ score[v.ID] = ScorePhi
+ case v.Op == OpPhi:
+ // We want all the phis first.
+ score[v.ID] = ScorePhi
+ case v.Op == OpVarDef:
+ // We want all the vardefs next.
+ score[v.ID] = ScoreVarDef
+ case v.Type.IsMemory():
+ // Schedule stores as early as possible. This tends to
+ // reduce register pressure. It also helps make sure
+ // VARDEF ops are scheduled before the corresponding LEA.
+ score[v.ID] = ScoreMemory
+ case v.Type.IsFlags():
+ // Schedule flag register generation as late as possible.
+ // This makes sure that we only have one live flags
+ // value at a time.
+ score[v.ID] = ScoreFlags
+ default:
+ score[v.ID] = ScoreDefault
+ }
+ }
+ if b.Control != nil && b.Control.Op != OpPhi {
+ // Force the control value to be scheduled at the end,
+ // unless it is a phi value (which must be first).
+ score[b.Control.ID] = ScoreControl
+
+ // Schedule values dependent on the control value at the end.
+ // This reduces the number of register spills. We don't find
+ // all values that depend on the control, just values with a
+ // direct dependency. This is cheaper and in testing there
+ // was no difference in the number of spills.
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ for _, a := range v.Args {
+ if a == b.Control {
+ score[v.ID] = ScoreControl
+ }
+ }
+ }
+ }
+ }
+
+ // Initialize priority queue with schedulable values.
+ for i := range priq {
+ priq[i] = priq[i][:0]
+ }
+ for _, v := range b.Values {
+ if uses[v.ID] == 0 {
+ s := score[v.ID]
+ priq[s] = append(priq[s], v)
+ }
+ }
+
+ // Schedule highest priority value, update use counts, repeat.
+ order = order[:0]
+ for {
+ // Find highest priority schedulable value.
+ var v *Value
+ for i := len(priq) - 1; i >= 0; i-- {
+ n := len(priq[i])
+ if n == 0 {
+ continue
+ }
+ v = priq[i][n-1]
+ priq[i] = priq[i][:n-1]
+ break
+ }
+ if v == nil {
+ break
+ }
+
+ // Add it to the schedule.
+ order = append(order, v)
+
+ // Update use counts of arguments.
+ for _, w := range v.Args {
+ if w.Block != b {
+ continue
+ }
+ uses[w.ID]--
+ if uses[w.ID] == 0 {
+ // All uses scheduled, w is now schedulable.
+ s := score[w.ID]
+ priq[s] = append(priq[s], w)
+ }
+ }
+ for _, w := range additionalArgs[v.ID] {
+ uses[w.ID]--
+ if uses[w.ID] == 0 {
+ // All uses scheduled, w is now schedulable.
+ s := score[w.ID]
+ priq[s] = append(priq[s], w)
+ }
+ }
+ }
+ if len(order) != len(b.Values) {
+ f.Fatalf("schedule does not include all values")
+ }
+ for i := 0; i < len(b.Values); i++ {
+ b.Values[i] = order[len(b.Values)-1-i]
+ }
+ }
+
+ f.scheduled = true
+}
diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go
new file mode 100644
index 0000000..0ff57e3
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/schedule_test.go
@@ -0,0 +1,57 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func TestSchedule(t *testing.T) {
+ c := testConfig(t)
+ cases := []fun{
+ Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem0", OpInitMem, TypeMem, 0, nil),
+ Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil),
+ Valu("v", OpConst64, TypeInt64, 12, nil),
+ Valu("mem1", OpStore, TypeMem, 8, nil, "ptr", "v", "mem0"),
+ Valu("mem2", OpStore, TypeMem, 8, nil, "ptr", "v", "mem1"),
+ Valu("mem3", OpStore, TypeInt64, 8, nil, "ptr", "sum", "mem2"),
+ Valu("l1", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"),
+ Valu("l2", OpLoad, TypeInt64, 0, nil, "ptr", "mem2"),
+ Valu("sum", OpAdd64, TypeInt64, 0, nil, "l1", "l2"),
+ Goto("exit")),
+ Bloc("exit",
+ Exit("mem3"))),
+ }
+ for _, c := range cases {
+ schedule(c.f)
+ if !isSingleLiveMem(c.f) {
+ t.Error("single-live-mem restriction not enforced by schedule for func:")
+ printFunc(c.f)
+ }
+ }
+}
+
+func isSingleLiveMem(f *Func) bool {
+ for _, b := range f.Blocks {
+ var liveMem *Value
+ for _, v := range b.Values {
+ for _, w := range v.Args {
+ if w.Type.IsMemory() {
+ if liveMem == nil {
+ liveMem = w
+ continue
+ }
+ if w != liveMem {
+ return false
+ }
+ }
+ }
+ if v.Type.IsMemory() {
+ liveMem = v
+ }
+ }
+ }
+ return true
+}
diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go
new file mode 100644
index 0000000..8d5e62f
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/shift_test.go
@@ -0,0 +1,48 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "testing"
+)
+
+func TestShiftConstAMD64(t *testing.T) {
+ c := testConfig(t)
+ fun := makeConstShiftFunc(c, 18, OpLsh64x64, TypeUInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0})
+ fun.f.Free()
+ fun = makeConstShiftFunc(c, 66, OpLsh64x64, TypeUInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0})
+ fun.f.Free()
+ fun = makeConstShiftFunc(c, 18, OpRsh64Ux64, TypeUInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0})
+ fun.f.Free()
+ fun = makeConstShiftFunc(c, 66, OpRsh64Ux64, TypeUInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0})
+ fun.f.Free()
+ fun = makeConstShiftFunc(c, 18, OpRsh64x64, TypeInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0})
+ fun.f.Free()
+ fun = makeConstShiftFunc(c, 66, OpRsh64x64, TypeInt64)
+ checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0})
+ fun.f.Free()
+}
+
+func makeConstShiftFunc(c *Config, amount int64, op Op, typ Type) fun {
+ ptyp := &TypeImpl{Size_: 8, Ptr: true, Name: "ptr"}
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("SP", OpSP, TypeUInt64, 0, nil),
+ Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"),
+ Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"),
+ Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"),
+ Valu("c", OpConst64, TypeUInt64, amount, nil),
+ Valu("shift", op, typ, 0, nil, "load", "c"),
+ Valu("store", OpStore, TypeMem, 8, nil, "resptr", "shift", "mem"),
+ Exit("store")))
+ Compile(fun.f)
+ return fun
+}
diff --git a/src/cmd/compile/internal/ssa/shortcircuit.go b/src/cmd/compile/internal/ssa/shortcircuit.go
new file mode 100644
index 0000000..d22a61a
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/shortcircuit.go
@@ -0,0 +1,144 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// Shortcircuit finds situations where branch directions
+// are always correlated and rewrites the CFG to take
+// advantage of that fact.
+// This optimization is useful for compiling && and || expressions.
+func shortcircuit(f *Func) {
+ // Step 1: Replace a phi arg with a constant if that arg
+ // is the control value of a preceding If block.
+ // b1:
+ // If a goto b2 else b3
+ // b2: <- b1 ...
+ // x = phi(a, ...)
+ //
+ // We can replace the "a" in the phi with the constant true.
+ ct := f.ConstBool(f.Entry.Line, f.Config.fe.TypeBool(), true)
+ cf := f.ConstBool(f.Entry.Line, f.Config.fe.TypeBool(), false)
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if v.Op != OpPhi {
+ continue
+ }
+ if !v.Type.IsBoolean() {
+ continue
+ }
+ for i, a := range v.Args {
+ p := b.Preds[i]
+ if p.Kind != BlockIf {
+ continue
+ }
+ if p.Control != a {
+ continue
+ }
+ if p.Succs[0] == b {
+ v.Args[i] = ct
+ } else {
+ v.Args[i] = cf
+ }
+ }
+ }
+ }
+
+ // Step 2: Compute which values are live across blocks.
+ live := make([]bool, f.NumValues())
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for _, a := range v.Args {
+ if a.Block != v.Block {
+ live[a.ID] = true
+ }
+ }
+ }
+ if b.Control != nil && b.Control.Block != b {
+ live[b.Control.ID] = true
+ }
+ }
+
+ // Step 3: Redirect control flow around known branches.
+ // p:
+ // ... goto b ...
+ // b: <- p ...
+ // v = phi(true, ...)
+ // if v goto t else u
+ // We can redirect p to go directly to t instead of b.
+ // (If v is not live after b).
+ for _, b := range f.Blocks {
+ if b.Kind != BlockIf {
+ continue
+ }
+ if len(b.Values) != 1 {
+ continue
+ }
+ v := b.Values[0]
+ if v.Op != OpPhi {
+ continue
+ }
+ if b.Control != v {
+ continue
+ }
+ if live[v.ID] {
+ continue
+ }
+ for i := 0; i < len(v.Args); i++ {
+ a := v.Args[i]
+ if a.Op != OpConstBool {
+ continue
+ }
+
+ // The predecessor we come in from.
+ p := b.Preds[i]
+ // The successor we always go to when coming in
+ // from that predecessor.
+ t := b.Succs[1-a.AuxInt]
+
+ // Change the edge p->b to p->t.
+ for j, x := range p.Succs {
+ if x == b {
+ p.Succs[j] = t
+ break
+ }
+ }
+
+ // Fix up t to have one more predecessor.
+ j := predIdx(t, b)
+ t.Preds = append(t.Preds, p)
+ for _, w := range t.Values {
+ if w.Op != OpPhi {
+ continue
+ }
+ w.Args = append(w.Args, w.Args[j])
+ }
+
+ // Fix up b to have one less predecessor.
+ n := len(b.Preds) - 1
+ b.Preds[i] = b.Preds[n]
+ b.Preds[n] = nil
+ b.Preds = b.Preds[:n]
+ v.Args[i] = v.Args[n]
+ v.Args[n] = nil
+ v.Args = v.Args[:n]
+ if n == 1 {
+ v.Op = OpCopy
+ // No longer a phi, stop optimizing here.
+ break
+ }
+ i--
+ }
+ }
+}
+
+// predIdx returns the index where p appears in the predecessor list of b.
+// p must be in the predecessor list of b.
+func predIdx(b, p *Block) int {
+ for i, x := range b.Preds {
+ if x == p {
+ return i
+ }
+ }
+ panic("predecessor not found")
+}
diff --git a/src/cmd/compile/internal/ssa/shortcircuit_test.go b/src/cmd/compile/internal/ssa/shortcircuit_test.go
new file mode 100644
index 0000000..f208801
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/shortcircuit_test.go
@@ -0,0 +1,50 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import "testing"
+
+func TestShortCircuit(t *testing.T) {
+ c := testConfig(t)
+
+ fun := Fun(c, "entry",
+ Bloc("entry",
+ Valu("mem", OpInitMem, TypeMem, 0, nil),
+ Valu("arg1", OpArg, TypeInt64, 0, nil),
+ Valu("arg2", OpArg, TypeInt64, 0, nil),
+ Valu("arg3", OpArg, TypeInt64, 0, nil),
+ Goto("b1")),
+ Bloc("b1",
+ Valu("cmp1", OpLess64, TypeBool, 0, nil, "arg1", "arg2"),
+ If("cmp1", "b2", "b3")),
+ Bloc("b2",
+ Valu("cmp2", OpLess64, TypeBool, 0, nil, "arg2", "arg3"),
+ Goto("b3")),
+ Bloc("b3",
+ Valu("phi2", OpPhi, TypeBool, 0, nil, "cmp1", "cmp2"),
+ If("phi2", "b4", "b5")),
+ Bloc("b4",
+ Valu("cmp3", OpLess64, TypeBool, 0, nil, "arg3", "arg1"),
+ Goto("b5")),
+ Bloc("b5",
+ Valu("phi3", OpPhi, TypeBool, 0, nil, "phi2", "cmp3"),
+ If("phi3", "b6", "b7")),
+ Bloc("b6",
+ Exit("mem")),
+ Bloc("b7",
+ Exit("mem")))
+
+ CheckFunc(fun.f)
+ shortcircuit(fun.f)
+ CheckFunc(fun.f)
+
+ for _, b := range fun.f.Blocks {
+ for _, v := range b.Values {
+ if v.Op == OpPhi {
+ t.Errorf("phi %s remains", v)
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/sparsemap.go b/src/cmd/compile/internal/ssa/sparsemap.go
new file mode 100644
index 0000000..6c0043b
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/sparsemap.go
@@ -0,0 +1,69 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// from http://research.swtch.com/sparse
+// in turn, from Briggs and Torczon
+
+type sparseEntry struct {
+ key ID
+ val int32
+}
+
+type sparseMap struct {
+ dense []sparseEntry
+ sparse []int
+}
+
+// newSparseMap returns a sparseMap that can map
+// integers between 0 and n-1 to int32s.
+func newSparseMap(n int) *sparseMap {
+ return &sparseMap{nil, make([]int, n)}
+}
+
+func (s *sparseMap) size() int {
+ return len(s.dense)
+}
+
+func (s *sparseMap) contains(k ID) bool {
+ i := s.sparse[k]
+ return i < len(s.dense) && s.dense[i].key == k
+}
+
+func (s *sparseMap) get(k ID) int32 {
+ i := s.sparse[k]
+ if i < len(s.dense) && s.dense[i].key == k {
+ return s.dense[i].val
+ }
+ return -1
+}
+
+func (s *sparseMap) set(k ID, v int32) {
+ i := s.sparse[k]
+ if i < len(s.dense) && s.dense[i].key == k {
+ s.dense[i].val = v
+ return
+ }
+ s.dense = append(s.dense, sparseEntry{k, v})
+ s.sparse[k] = len(s.dense) - 1
+}
+
+func (s *sparseMap) remove(k ID) {
+ i := s.sparse[k]
+ if i < len(s.dense) && s.dense[i].key == k {
+ y := s.dense[len(s.dense)-1]
+ s.dense[i] = y
+ s.sparse[y.key] = i
+ s.dense = s.dense[:len(s.dense)-1]
+ }
+}
+
+func (s *sparseMap) clear() {
+ s.dense = s.dense[:0]
+}
+
+func (s *sparseMap) contents() []sparseEntry {
+ return s.dense
+}
diff --git a/src/cmd/compile/internal/ssa/sparseset.go b/src/cmd/compile/internal/ssa/sparseset.go
new file mode 100644
index 0000000..66bebf1
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/sparseset.go
@@ -0,0 +1,79 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// from http://research.swtch.com/sparse
+// in turn, from Briggs and Torczon
+
+type sparseSet struct {
+ dense []ID
+ sparse []int
+}
+
+// newSparseSet returns a sparseSet that can represent
+// integers between 0 and n-1
+func newSparseSet(n int) *sparseSet {
+ return &sparseSet{nil, make([]int, n)}
+}
+
+func (s *sparseSet) cap() int {
+ return len(s.sparse)
+}
+
+func (s *sparseSet) size() int {
+ return len(s.dense)
+}
+
+func (s *sparseSet) contains(x ID) bool {
+ i := s.sparse[x]
+ return i < len(s.dense) && s.dense[i] == x
+}
+
+func (s *sparseSet) add(x ID) {
+ i := s.sparse[x]
+ if i < len(s.dense) && s.dense[i] == x {
+ return
+ }
+ s.dense = append(s.dense, x)
+ s.sparse[x] = len(s.dense) - 1
+}
+
+func (s *sparseSet) addAll(a []ID) {
+ for _, x := range a {
+ s.add(x)
+ }
+}
+
+func (s *sparseSet) addAllValues(a []*Value) {
+ for _, v := range a {
+ s.add(v.ID)
+ }
+}
+
+func (s *sparseSet) remove(x ID) {
+ i := s.sparse[x]
+ if i < len(s.dense) && s.dense[i] == x {
+ y := s.dense[len(s.dense)-1]
+ s.dense[i] = y
+ s.sparse[y] = i
+ s.dense = s.dense[:len(s.dense)-1]
+ }
+}
+
+// pop removes an arbitrary element from the set.
+// The set must be nonempty.
+func (s *sparseSet) pop() ID {
+ x := s.dense[len(s.dense)-1]
+ s.dense = s.dense[:len(s.dense)-1]
+ return x
+}
+
+func (s *sparseSet) clear() {
+ s.dense = s.dense[:0]
+}
+
+func (s *sparseSet) contents() []ID {
+ return s.dense
+}
diff --git a/src/cmd/compile/internal/ssa/sparsetree.go b/src/cmd/compile/internal/ssa/sparsetree.go
new file mode 100644
index 0000000..9a08f35
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/sparsetree.go
@@ -0,0 +1,129 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+type sparseTreeNode struct {
+ child *Block
+ sibling *Block
+ parent *Block
+
+ // Every block has 6 numbers associated with it:
+ // entry-1, entry, entry+1, exit-1, and exit, exit+1.
+ // entry and exit are conceptually the top of the block (phi functions)
+ // entry+1 and exit-1 are conceptually the bottom of the block (ordinary defs)
+ // entry-1 and exit+1 are conceptually "just before" the block (conditions flowing in)
+ //
+ // This simplifies life if we wish to query information about x
+ // when x is both an input to and output of a block.
+ entry, exit int32
+}
+
+const (
+ // When used to lookup up definitions in a sparse tree,
+ // these adjustments to a block's entry (+adjust) and
+ // exit (-adjust) numbers allow a distinction to be made
+ // between assignments (typically branch-dependent
+ // conditionals) occurring "before" phi functions, the
+ // phi functions, and at the bottom of a block.
+ ADJUST_BEFORE = -1 // defined before phi
+ ADJUST_TOP = 0 // defined by phi
+ ADJUST_BOTTOM = 1 // defined within block
+)
+
+// A sparseTree is a tree of Blocks.
+// It allows rapid ancestor queries,
+// such as whether one block dominates another.
+type sparseTree []sparseTreeNode
+
+// newSparseTree creates a sparseTree from a block-to-parent map (array indexed by Block.ID)
+func newSparseTree(f *Func, parentOf []*Block) sparseTree {
+ t := make(sparseTree, f.NumBlocks())
+ for _, b := range f.Blocks {
+ n := &t[b.ID]
+ if p := parentOf[b.ID]; p != nil {
+ n.parent = p
+ n.sibling = t[p.ID].child
+ t[p.ID].child = b
+ }
+ }
+ t.numberBlock(f.Entry, 1)
+ return t
+}
+
+// numberBlock assigns entry and exit numbers for b and b's
+// children in an in-order walk from a gappy sequence, where n
+// is the first number not yet assigned or reserved. N should
+// be larger than zero. For each entry and exit number, the
+// values one larger and smaller are reserved to indicate
+// "strictly above" and "strictly below". numberBlock returns
+// the smallest number not yet assigned or reserved (i.e., the
+// exit number of the last block visited, plus two, because
+// last.exit+1 is a reserved value.)
+//
+// examples:
+//
+// single node tree Root, call with n=1
+// entry=2 Root exit=5; returns 7
+//
+// two node tree, Root->Child, call with n=1
+// entry=2 Root exit=11; returns 13
+// entry=5 Child exit=8
+//
+// three node tree, Root->(Left, Right), call with n=1
+// entry=2 Root exit=17; returns 19
+// entry=5 Left exit=8; entry=11 Right exit=14
+//
+// This is the in-order sequence of assigned and reserved numbers
+// for the last example:
+// root left left right right root
+// 1 2e 3 | 4 5e 6 | 7 8x 9 | 10 11e 12 | 13 14x 15 | 16 17x 18
+
+func (t sparseTree) numberBlock(b *Block, n int32) int32 {
+ // reserve n for entry-1, assign n+1 to entry
+ n++
+ t[b.ID].entry = n
+ // reserve n+1 for entry+1, n+2 is next free number
+ n += 2
+ for c := t[b.ID].child; c != nil; c = t[c.ID].sibling {
+ n = t.numberBlock(c, n) // preserves n = next free number
+ }
+ // reserve n for exit-1, assign n+1 to exit
+ n++
+ t[b.ID].exit = n
+ // reserve n+1 for exit+1, n+2 is next free number, returned.
+ return n + 2
+}
+
+// Sibling returns a sibling of x in the dominator tree (i.e.,
+// a node with the same immediate dominator) or nil if there
+// are no remaining siblings in the arbitrary but repeatable
+// order chosen. Because the Child-Sibling order is used
+// to assign entry and exit numbers in the treewalk, those
+// numbers are also consistent with this order (i.e.,
+// Sibling(x) has entry number larger than x's exit number).
+func (t sparseTree) Sibling(x *Block) *Block {
+ return t[x.ID].sibling
+}
+
+// Child returns a child of x in the dominator tree, or
+// nil if there are none. The choice of first child is
+// arbitrary but repeatable.
+func (t sparseTree) Child(x *Block) *Block {
+ return t[x.ID].child
+}
+
+// isAncestorEq reports whether x is an ancestor of or equal to y.
+func (t sparseTree) isAncestorEq(x, y *Block) bool {
+ xx := &t[x.ID]
+ yy := &t[y.ID]
+ return xx.entry <= yy.entry && yy.exit <= xx.exit
+}
+
+// isAncestor reports whether x is a strict ancestor of y.
+func (t sparseTree) isAncestor(x, y *Block) bool {
+ xx := &t[x.ID]
+ yy := &t[y.ID]
+ return xx.entry < yy.entry && yy.exit < xx.exit
+}
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
new file mode 100644
index 0000000..0e6cae0
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -0,0 +1,321 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// TODO: live at start of block instead?
+
+package ssa
+
+import "fmt"
+
+const stackDebug = false // TODO: compiler flag
+
+type stackAllocState struct {
+ f *Func
+ values []stackValState
+ live [][]ID // live[b.id] = live values at the end of block b.
+ interfere [][]ID // interfere[v.id] = values that interfere with v.
+}
+
+type stackValState struct {
+ typ Type
+ spill *Value
+ needSlot bool
+}
+
+// stackalloc allocates storage in the stack frame for
+// all Values that did not get a register.
+// Returns a map from block ID to the stack values live at the end of that block.
+func stackalloc(f *Func, spillLive [][]ID) [][]ID {
+ if stackDebug {
+ fmt.Println("before stackalloc")
+ fmt.Println(f.String())
+ }
+ var s stackAllocState
+ s.init(f, spillLive)
+ s.stackalloc()
+ return s.live
+}
+
+func (s *stackAllocState) init(f *Func, spillLive [][]ID) {
+ s.f = f
+
+ // Initialize value information.
+ s.values = make([]stackValState, f.NumValues())
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ s.values[v.ID].typ = v.Type
+ s.values[v.ID].needSlot = !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags() && f.getHome(v.ID) == nil && !v.rematerializeable()
+ if stackDebug && s.values[v.ID].needSlot {
+ fmt.Printf("%s needs a stack slot\n", v)
+ }
+ if v.Op == OpStoreReg {
+ s.values[v.Args[0].ID].spill = v
+ }
+ }
+ }
+
+ // Compute liveness info for values needing a slot.
+ s.computeLive(spillLive)
+
+ // Build interference graph among values needing a slot.
+ s.buildInterferenceGraph()
+}
+
+func (s *stackAllocState) stackalloc() {
+ f := s.f
+
+ // Build map from values to their names, if any.
+ // A value may be associated with more than one name (e.g. after
+ // the assignment i=j). This step picks one name per value arbitrarily.
+ names := make([]LocalSlot, f.NumValues())
+ for _, name := range f.Names {
+ // Note: not "range f.NamedValues" above, because
+ // that would be nondeterministic.
+ for _, v := range f.NamedValues[name] {
+ names[v.ID] = name
+ }
+ }
+
+ // Allocate args to their assigned locations.
+ for _, v := range f.Entry.Values {
+ if v.Op != OpArg {
+ continue
+ }
+ loc := LocalSlot{v.Aux.(GCNode), v.Type, v.AuxInt}
+ if stackDebug {
+ fmt.Printf("stackalloc %s to %s\n", v, loc.Name())
+ }
+ f.setHome(v, loc)
+ }
+
+ // For each type, we keep track of all the stack slots we
+ // have allocated for that type.
+ // TODO: share slots among equivalent types. We would need to
+ // only share among types with the same GC signature. See the
+ // type.Equal calls below for where this matters.
+ locations := map[Type][]LocalSlot{}
+
+ // Each time we assign a stack slot to a value v, we remember
+ // the slot we used via an index into locations[v.Type].
+ slots := make([]int, f.NumValues())
+ for i := f.NumValues() - 1; i >= 0; i-- {
+ slots[i] = -1
+ }
+
+ // Pick a stack slot for each value needing one.
+ used := make([]bool, f.NumValues())
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ if !s.values[v.ID].needSlot {
+ continue
+ }
+ if v.Op == OpArg {
+ continue // already picked
+ }
+
+ // If this is a named value, try to use the name as
+ // the spill location.
+ var name LocalSlot
+ if v.Op == OpStoreReg {
+ name = names[v.Args[0].ID]
+ } else {
+ name = names[v.ID]
+ }
+ if name.N != nil && v.Type.Equal(name.Type) {
+ for _, id := range s.interfere[v.ID] {
+ h := f.getHome(id)
+ if h != nil && h.(LocalSlot) == name {
+ // A variable can interfere with itself.
+ // It is rare, but but it can happen.
+ goto noname
+ }
+ }
+ if stackDebug {
+ fmt.Printf("stackalloc %s to %s\n", v, name.Name())
+ }
+ f.setHome(v, name)
+ continue
+ }
+
+ noname:
+ // Set of stack slots we could reuse.
+ locs := locations[v.Type]
+ // Mark all positions in locs used by interfering values.
+ for i := 0; i < len(locs); i++ {
+ used[i] = false
+ }
+ for _, xid := range s.interfere[v.ID] {
+ slot := slots[xid]
+ if slot >= 0 {
+ used[slot] = true
+ }
+ }
+ // Find an unused stack slot.
+ var i int
+ for i = 0; i < len(locs); i++ {
+ if !used[i] {
+ break
+ }
+ }
+ // If there is no unused stack slot, allocate a new one.
+ if i == len(locs) {
+ locs = append(locs, LocalSlot{N: f.Config.fe.Auto(v.Type), Type: v.Type, Off: 0})
+ locations[v.Type] = locs
+ }
+ // Use the stack variable at that index for v.
+ loc := locs[i]
+ if stackDebug {
+ fmt.Printf("stackalloc %s to %s\n", v, loc.Name())
+ }
+ f.setHome(v, loc)
+ slots[v.ID] = i
+ }
+ }
+}
+
+// computeLive computes a map from block ID to a list of
+// stack-slot-needing value IDs live at the end of that block.
+// TODO: this could be quadratic if lots of variables are live across lots of
+// basic blocks. Figure out a way to make this function (or, more precisely, the user
+// of this function) require only linear size & time.
+func (s *stackAllocState) computeLive(spillLive [][]ID) {
+ s.live = make([][]ID, s.f.NumBlocks())
+ var phis []*Value
+ live := s.f.newSparseSet(s.f.NumValues())
+ defer s.f.retSparseSet(live)
+ t := s.f.newSparseSet(s.f.NumValues())
+ defer s.f.retSparseSet(t)
+
+ // Instead of iterating over f.Blocks, iterate over their postordering.
+ // Liveness information flows backward, so starting at the end
+ // increases the probability that we will stabilize quickly.
+ po := postorder(s.f)
+ for {
+ changed := false
+ for _, b := range po {
+ // Start with known live values at the end of the block
+ live.clear()
+ live.addAll(s.live[b.ID])
+
+ // Propagate backwards to the start of the block
+ phis = phis[:0]
+ for i := len(b.Values) - 1; i >= 0; i-- {
+ v := b.Values[i]
+ live.remove(v.ID)
+ if v.Op == OpPhi {
+ // Save phi for later.
+ // Note: its args might need a stack slot even though
+ // the phi itself doesn't. So don't use needSlot.
+ if !v.Type.IsMemory() && !v.Type.IsVoid() {
+ phis = append(phis, v)
+ }
+ continue
+ }
+ for _, a := range v.Args {
+ if s.values[a.ID].needSlot {
+ live.add(a.ID)
+ }
+ }
+ }
+
+ // for each predecessor of b, expand its list of live-at-end values
+ // invariant: s contains the values live at the start of b (excluding phi inputs)
+ for i, p := range b.Preds {
+ t.clear()
+ t.addAll(s.live[p.ID])
+ t.addAll(live.contents())
+ t.addAll(spillLive[p.ID])
+ for _, v := range phis {
+ a := v.Args[i]
+ if s.values[a.ID].needSlot {
+ t.add(a.ID)
+ }
+ if spill := s.values[a.ID].spill; spill != nil {
+ //TODO: remove? Subsumed by SpillUse?
+ t.add(spill.ID)
+ }
+ }
+ if t.size() == len(s.live[p.ID]) {
+ continue
+ }
+ // grow p's live set
+ s.live[p.ID] = append(s.live[p.ID][:0], t.contents()...)
+ changed = true
+ }
+ }
+
+ if !changed {
+ break
+ }
+ }
+ if stackDebug {
+ for _, b := range s.f.Blocks {
+ fmt.Printf("stacklive %s %v\n", b, s.live[b.ID])
+ }
+ }
+}
+
+func (f *Func) getHome(vid ID) Location {
+ if int(vid) >= len(f.RegAlloc) {
+ return nil
+ }
+ return f.RegAlloc[vid]
+}
+
+func (f *Func) setHome(v *Value, loc Location) {
+ for v.ID >= ID(len(f.RegAlloc)) {
+ f.RegAlloc = append(f.RegAlloc, nil)
+ }
+ f.RegAlloc[v.ID] = loc
+}
+
+func (s *stackAllocState) buildInterferenceGraph() {
+ f := s.f
+ s.interfere = make([][]ID, f.NumValues())
+ live := f.newSparseSet(f.NumValues())
+ defer f.retSparseSet(live)
+ for _, b := range f.Blocks {
+ // Propagate liveness backwards to the start of the block.
+ // Two values interfere if one is defined while the other is live.
+ live.clear()
+ live.addAll(s.live[b.ID])
+ for i := len(b.Values) - 1; i >= 0; i-- {
+ v := b.Values[i]
+ if s.values[v.ID].needSlot {
+ live.remove(v.ID)
+ for _, id := range live.contents() {
+ if s.values[v.ID].typ.Equal(s.values[id].typ) {
+ s.interfere[v.ID] = append(s.interfere[v.ID], id)
+ s.interfere[id] = append(s.interfere[id], v.ID)
+ }
+ }
+ }
+ for _, a := range v.Args {
+ if s.values[a.ID].needSlot {
+ live.add(a.ID)
+ }
+ }
+ if v.Op == OpArg && s.values[v.ID].needSlot {
+ // OpArg is an input argument which is pre-spilled.
+ // We add back v.ID here because we want this value
+ // to appear live even before this point. Being live
+ // all the way to the start of the entry block prevents other
+ // values from being allocated to the same slot and clobbering
+ // the input value before we have a chance to load it.
+ live.add(v.ID)
+ }
+ }
+ }
+ if stackDebug {
+ for vid, i := range s.interfere {
+ if len(i) > 0 {
+ fmt.Printf("v%d interferes with", vid)
+ for _, x := range i {
+ fmt.Printf(" v%d", x)
+ }
+ fmt.Println()
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go
new file mode 100644
index 0000000..ecb43c1
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/tighten.go
@@ -0,0 +1,88 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// tighten moves Values closer to the Blocks in which they are used.
+// This can reduce the amount of register spilling required,
+// if it doesn't also create more live values.
+// For now, it handles only the trivial case in which a
+// Value with one or fewer args is only used in a single Block,
+// and not in a phi value.
+// TODO: Do something smarter.
+// A Value can be moved to any block that
+// dominates all blocks in which it is used.
+// Figure out when that will be an improvement.
+func tighten(f *Func) {
+ // For each value, the number of blocks in which it is used.
+ uses := make([]int32, f.NumValues())
+
+ // For each value, whether that value is ever an arg to a phi value.
+ phi := make([]bool, f.NumValues())
+
+ // For each value, one block in which that value is used.
+ home := make([]*Block, f.NumValues())
+
+ changed := true
+ for changed {
+ changed = false
+
+ // Reset uses
+ for i := range uses {
+ uses[i] = 0
+ }
+ // No need to reset home; any relevant values will be written anew anyway.
+ // No need to reset phi; once used in a phi, always used in a phi.
+
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for _, w := range v.Args {
+ if v.Op == OpPhi {
+ phi[w.ID] = true
+ }
+ uses[w.ID]++
+ home[w.ID] = b
+ }
+ }
+ if b.Control != nil {
+ uses[b.Control.ID]++
+ home[b.Control.ID] = b
+ }
+ }
+
+ for _, b := range f.Blocks {
+ for i := 0; i < len(b.Values); i++ {
+ v := b.Values[i]
+ if v.Op == OpPhi || v.Op == OpGetClosurePtr || v.Op == OpConvert || v.Op == OpArg {
+ // GetClosurePtr & Arg must stay in entry block.
+ // OpConvert must not float over call sites.
+ // TODO do we instead need a dependence edge of some sort for OpConvert?
+ // Would memory do the trick, or do we need something else that relates
+ // to safe point operations?
+ continue
+ }
+ if len(v.Args) > 0 && v.Args[len(v.Args)-1].Type.IsMemory() {
+ // We can't move values which have a memory arg - it might
+ // make two memory values live across a block boundary.
+ continue
+ }
+ if uses[v.ID] == 1 && !phi[v.ID] && home[v.ID] != b && len(v.Args) < 2 {
+ // v is used in exactly one block, and it is not b.
+ // Furthermore, it takes at most one input,
+ // so moving it will not increase the
+ // number of live values anywhere.
+ // Move v to that block.
+ c := home[v.ID]
+ c.Values = append(c.Values, v)
+ v.Block = c
+ last := len(b.Values) - 1
+ b.Values[i] = b.Values[last]
+ b.Values[last] = nil
+ b.Values = b.Values[:last]
+ changed = true
+ }
+ }
+ }
+ }
+}
diff --git a/src/cmd/compile/internal/ssa/trim.go b/src/cmd/compile/internal/ssa/trim.go
new file mode 100644
index 0000000..594d2aa
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/trim.go
@@ -0,0 +1,37 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// trim removes blocks with no code in them.
+// These blocks were inserted to remove critical edges.
+func trim(f *Func) {
+ i := 0
+ for _, b := range f.Blocks {
+ if b.Kind != BlockPlain || len(b.Values) != 0 || len(b.Preds) != 1 {
+ f.Blocks[i] = b
+ i++
+ continue
+ }
+ // TODO: handle len(b.Preds)>1 case.
+
+ // Splice b out of the graph.
+ pred := b.Preds[0]
+ succ := b.Succs[0]
+ for j, s := range pred.Succs {
+ if s == b {
+ pred.Succs[j] = succ
+ }
+ }
+ for j, p := range succ.Preds {
+ if p == b {
+ succ.Preds[j] = pred
+ }
+ }
+ }
+ for j := i; j < len(f.Blocks); j++ {
+ f.Blocks[j] = nil
+ }
+ f.Blocks = f.Blocks[:i]
+}
diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go
new file mode 100644
index 0000000..a23989c8
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/type.go
@@ -0,0 +1,131 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// TODO: use go/types instead?
+
+// A type interface used to import cmd/internal/gc:Type
+// Type instances are not guaranteed to be canonical.
+type Type interface {
+ Size() int64 // return the size in bytes
+ Alignment() int64
+
+ IsBoolean() bool // is a named or unnamed boolean type
+ IsInteger() bool // ... ditto for the others
+ IsSigned() bool
+ IsFloat() bool
+ IsComplex() bool
+ IsPtr() bool
+ IsString() bool
+ IsSlice() bool
+ IsArray() bool
+ IsStruct() bool
+ IsInterface() bool
+
+ IsMemory() bool // special ssa-package-only types
+ IsFlags() bool
+ IsVoid() bool
+
+ Elem() Type // given []T or *T or [n]T, return T
+ PtrTo() Type // given T, return *T
+
+ NumFields() int64 // # of fields of a struct
+ FieldType(i int64) Type // type of ith field of the struct
+ FieldOff(i int64) int64 // offset of ith field of the struct
+
+ NumElem() int64 // # of elements of an array
+
+ String() string
+ SimpleString() string // a coarser generic description of T, e.g. T's underlying type
+ Equal(Type) bool
+ Compare(Type) Cmp // compare types, returning one of CMPlt, CMPeq, CMPgt.
+}
+
+// Special compiler-only types.
+type CompilerType struct {
+ Name string
+ Memory bool
+ Flags bool
+ Void bool
+ Int128 bool
+}
+
+func (t *CompilerType) Size() int64 { return 0 } // Size in bytes
+func (t *CompilerType) Alignment() int64 { return 0 }
+func (t *CompilerType) IsBoolean() bool { return false }
+func (t *CompilerType) IsInteger() bool { return false }
+func (t *CompilerType) IsSigned() bool { return false }
+func (t *CompilerType) IsFloat() bool { return false }
+func (t *CompilerType) IsComplex() bool { return false }
+func (t *CompilerType) IsPtr() bool { return false }
+func (t *CompilerType) IsString() bool { return false }
+func (t *CompilerType) IsSlice() bool { return false }
+func (t *CompilerType) IsArray() bool { return false }
+func (t *CompilerType) IsStruct() bool { return false }
+func (t *CompilerType) IsInterface() bool { return false }
+func (t *CompilerType) IsMemory() bool { return t.Memory }
+func (t *CompilerType) IsFlags() bool { return t.Flags }
+func (t *CompilerType) IsVoid() bool { return t.Void }
+func (t *CompilerType) String() string { return t.Name }
+func (t *CompilerType) SimpleString() string { return t.Name }
+func (t *CompilerType) Elem() Type { panic("not implemented") }
+func (t *CompilerType) PtrTo() Type { panic("not implemented") }
+func (t *CompilerType) NumFields() int64 { panic("not implemented") }
+func (t *CompilerType) FieldType(i int64) Type { panic("not implemented") }
+func (t *CompilerType) FieldOff(i int64) int64 { panic("not implemented") }
+func (t *CompilerType) NumElem() int64 { panic("not implemented") }
+
+// Cmp is a comparison between values a and b.
+// -1 if a < b
+// 0 if a == b
+// 1 if a > b
+type Cmp int8
+
+const (
+ CMPlt = Cmp(-1)
+ CMPeq = Cmp(0)
+ CMPgt = Cmp(1)
+)
+
+func (t *CompilerType) Compare(u Type) Cmp {
+ x, ok := u.(*CompilerType)
+ // ssa.CompilerType is smaller than any other type
+ if !ok {
+ return CMPlt
+ }
+ if t == x {
+ return CMPeq
+ }
+ // desire fast sorting, not pretty sorting.
+ if len(t.Name) == len(x.Name) {
+ if t.Name == x.Name {
+ return CMPeq
+ }
+ if t.Name < x.Name {
+ return CMPlt
+ }
+ return CMPgt
+ }
+ if len(t.Name) > len(x.Name) {
+ return CMPgt
+ }
+ return CMPlt
+}
+
+func (t *CompilerType) Equal(u Type) bool {
+ x, ok := u.(*CompilerType)
+ if !ok {
+ return false
+ }
+ return x == t
+}
+
+var (
+ TypeInvalid = &CompilerType{Name: "invalid"}
+ TypeMem = &CompilerType{Name: "mem", Memory: true}
+ TypeFlags = &CompilerType{Name: "flags", Flags: true}
+ TypeVoid = &CompilerType{Name: "void", Void: true}
+ TypeInt128 = &CompilerType{Name: "int128", Int128: true}
+)
diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go
new file mode 100644
index 0000000..26c8223
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/type_test.go
@@ -0,0 +1,100 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// Stub implementation used for testing.
+type TypeImpl struct {
+ Size_ int64
+ Align int64
+ Boolean bool
+ Integer bool
+ Signed bool
+ Float bool
+ Complex bool
+ Ptr bool
+ string bool
+ slice bool
+ array bool
+ struct_ bool
+ inter bool
+ Elem_ Type
+
+ Name string
+}
+
+func (t *TypeImpl) Size() int64 { return t.Size_ }
+func (t *TypeImpl) Alignment() int64 { return t.Align }
+func (t *TypeImpl) IsBoolean() bool { return t.Boolean }
+func (t *TypeImpl) IsInteger() bool { return t.Integer }
+func (t *TypeImpl) IsSigned() bool { return t.Signed }
+func (t *TypeImpl) IsFloat() bool { return t.Float }
+func (t *TypeImpl) IsComplex() bool { return t.Complex }
+func (t *TypeImpl) IsPtr() bool { return t.Ptr }
+func (t *TypeImpl) IsString() bool { return t.string }
+func (t *TypeImpl) IsSlice() bool { return t.slice }
+func (t *TypeImpl) IsArray() bool { return t.array }
+func (t *TypeImpl) IsStruct() bool { return t.struct_ }
+func (t *TypeImpl) IsInterface() bool { return t.inter }
+func (t *TypeImpl) IsMemory() bool { return false }
+func (t *TypeImpl) IsFlags() bool { return false }
+func (t *TypeImpl) IsVoid() bool { return false }
+func (t *TypeImpl) String() string { return t.Name }
+func (t *TypeImpl) SimpleString() string { return t.Name }
+func (t *TypeImpl) Elem() Type { return t.Elem_ }
+func (t *TypeImpl) PtrTo() Type { panic("not implemented") }
+func (t *TypeImpl) NumFields() int64 { panic("not implemented") }
+func (t *TypeImpl) FieldType(i int64) Type { panic("not implemented") }
+func (t *TypeImpl) FieldOff(i int64) int64 { panic("not implemented") }
+func (t *TypeImpl) NumElem() int64 { panic("not implemented") }
+
+func (t *TypeImpl) Equal(u Type) bool {
+ x, ok := u.(*TypeImpl)
+ if !ok {
+ return false
+ }
+ return x == t
+}
+
+func (t *TypeImpl) Compare(u Type) Cmp {
+ x, ok := u.(*TypeImpl)
+ // ssa.CompilerType < ssa.TypeImpl < gc.Type
+ if !ok {
+ _, ok := u.(*CompilerType)
+ if ok {
+ return CMPgt
+ }
+ return CMPlt
+ }
+ if t == x {
+ return CMPeq
+ }
+ if t.Name < x.Name {
+ return CMPlt
+ }
+ if t.Name > x.Name {
+ return CMPgt
+ }
+ return CMPeq
+
+}
+
+var (
+ // shortcuts for commonly used basic types
+ TypeInt8 = &TypeImpl{Size_: 1, Align: 1, Integer: true, Signed: true, Name: "int8"}
+ TypeInt16 = &TypeImpl{Size_: 2, Align: 2, Integer: true, Signed: true, Name: "int16"}
+ TypeInt32 = &TypeImpl{Size_: 4, Align: 4, Integer: true, Signed: true, Name: "int32"}
+ TypeInt64 = &TypeImpl{Size_: 8, Align: 8, Integer: true, Signed: true, Name: "int64"}
+ TypeFloat32 = &TypeImpl{Size_: 4, Align: 4, Float: true, Name: "float32"}
+ TypeFloat64 = &TypeImpl{Size_: 8, Align: 8, Float: true, Name: "float64"}
+ TypeComplex64 = &TypeImpl{Size_: 8, Align: 4, Complex: true, Name: "complex64"}
+ TypeComplex128 = &TypeImpl{Size_: 16, Align: 8, Complex: true, Name: "complex128"}
+ TypeUInt8 = &TypeImpl{Size_: 1, Align: 1, Integer: true, Name: "uint8"}
+ TypeUInt16 = &TypeImpl{Size_: 2, Align: 2, Integer: true, Name: "uint16"}
+ TypeUInt32 = &TypeImpl{Size_: 4, Align: 4, Integer: true, Name: "uint32"}
+ TypeUInt64 = &TypeImpl{Size_: 8, Align: 8, Integer: true, Name: "uint64"}
+ TypeBool = &TypeImpl{Size_: 1, Align: 1, Boolean: true, Name: "bool"}
+ TypeBytePtr = &TypeImpl{Size_: 8, Align: 8, Ptr: true, Name: "*byte"}
+ TypeInt64Ptr = &TypeImpl{Size_: 8, Align: 8, Ptr: true, Name: "*int64"}
+)
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
new file mode 100644
index 0000000..cc8c9fe
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -0,0 +1,259 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+ "fmt"
+ "math"
+)
+
+// A Value represents a value in the SSA representation of the program.
+// The ID and Type fields must not be modified. The remainder may be modified
+// if they preserve the value of the Value (e.g. changing a (mul 2 x) to an (add x x)).
+type Value struct {
+ // A unique identifier for the value. For performance we allocate these IDs
+ // densely starting at 1. There is no guarantee that there won't be occasional holes, though.
+ ID ID
+
+ // The operation that computes this value. See op.go.
+ Op Op
+
+ // The type of this value. Normally this will be a Go type, but there
+ // are a few other pseudo-types, see type.go.
+ Type Type
+
+ // Auxiliary info for this value. The type of this information depends on the opcode and type.
+ // AuxInt is used for integer values, Aux is used for other values.
+ AuxInt int64
+ Aux interface{}
+
+ // Arguments of this value
+ Args []*Value
+
+ // Containing basic block
+ Block *Block
+
+ // Source line number
+ Line int32
+
+ // Storage for the first two args
+ argstorage [2]*Value
+}
+
+// Examples:
+// Opcode aux args
+// OpAdd nil 2
+// OpConst string 0 string constant
+// OpConst int64 0 int64 constant
+// OpAddcq int64 1 amd64 op: v = arg[0] + constant
+
+// short form print. Just v#.
+func (v *Value) String() string {
+ if v == nil {
+ return "nil" // should never happen, but not panicking helps with debugging
+ }
+ return fmt.Sprintf("v%d", v.ID)
+}
+
+func (v *Value) AuxInt8() int8 {
+ if opcodeTable[v.Op].auxType != auxInt8 {
+ v.Fatalf("op %s doesn't have an int8 aux field", v.Op)
+ }
+ return int8(v.AuxInt)
+}
+
+func (v *Value) AuxInt16() int16 {
+ if opcodeTable[v.Op].auxType != auxInt16 {
+ v.Fatalf("op %s doesn't have an int16 aux field", v.Op)
+ }
+ return int16(v.AuxInt)
+}
+
+func (v *Value) AuxInt32() int32 {
+ if opcodeTable[v.Op].auxType != auxInt32 {
+ v.Fatalf("op %s doesn't have an int32 aux field", v.Op)
+ }
+ return int32(v.AuxInt)
+}
+
+// AuxInt2Int64 is used to sign extend the lower bits of AuxInt according to
+// the size of AuxInt specified in the opcode table.
+func (v *Value) AuxInt2Int64() int64 {
+ switch opcodeTable[v.Op].auxType {
+ case auxInt64:
+ return v.AuxInt
+ case auxInt32:
+ return int64(int32(v.AuxInt))
+ case auxInt16:
+ return int64(int16(v.AuxInt))
+ case auxInt8:
+ return int64(int8(v.AuxInt))
+ default:
+ v.Fatalf("op %s doesn't have an aux int field", v.Op)
+ return -1
+ }
+}
+
+func (v *Value) AuxFloat() float64 {
+ if opcodeTable[v.Op].auxType != auxFloat {
+ v.Fatalf("op %s doesn't have a float aux field", v.Op)
+ }
+ return math.Float64frombits(uint64(v.AuxInt))
+}
+func (v *Value) AuxValAndOff() ValAndOff {
+ if opcodeTable[v.Op].auxType != auxSymValAndOff {
+ v.Fatalf("op %s doesn't have a ValAndOff aux field", v.Op)
+ }
+ return ValAndOff(v.AuxInt)
+}
+
+// long form print. v# = opcode <type> [aux] args [: reg]
+func (v *Value) LongString() string {
+ s := fmt.Sprintf("v%d = %s", v.ID, v.Op.String())
+ s += " <" + v.Type.String() + ">"
+ switch opcodeTable[v.Op].auxType {
+ case auxBool:
+ if v.AuxInt == 0 {
+ s += " [false]"
+ } else {
+ s += " [true]"
+ }
+ case auxInt8:
+ s += fmt.Sprintf(" [%d]", v.AuxInt8())
+ case auxInt16:
+ s += fmt.Sprintf(" [%d]", v.AuxInt16())
+ case auxInt32:
+ s += fmt.Sprintf(" [%d]", v.AuxInt32())
+ case auxInt64:
+ s += fmt.Sprintf(" [%d]", v.AuxInt)
+ case auxFloat:
+ s += fmt.Sprintf(" [%g]", v.AuxFloat())
+ case auxString:
+ s += fmt.Sprintf(" {%s}", v.Aux)
+ case auxSym:
+ if v.Aux != nil {
+ s += fmt.Sprintf(" {%s}", v.Aux)
+ }
+ case auxSymOff:
+ if v.Aux != nil {
+ s += fmt.Sprintf(" {%s}", v.Aux)
+ }
+ s += fmt.Sprintf(" [%d]", v.AuxInt)
+ case auxSymValAndOff:
+ if v.Aux != nil {
+ s += fmt.Sprintf(" {%s}", v.Aux)
+ }
+ s += fmt.Sprintf(" [%s]", v.AuxValAndOff())
+ }
+ for _, a := range v.Args {
+ s += fmt.Sprintf(" %v", a)
+ }
+ r := v.Block.Func.RegAlloc
+ if int(v.ID) < len(r) && r[v.ID] != nil {
+ s += " : " + r[v.ID].Name()
+ }
+ return s
+}
+
+func (v *Value) AddArg(w *Value) {
+ if v.Args == nil {
+ v.resetArgs() // use argstorage
+ }
+ v.Args = append(v.Args, w)
+}
+func (v *Value) AddArgs(a ...*Value) {
+ if v.Args == nil {
+ v.resetArgs() // use argstorage
+ }
+ v.Args = append(v.Args, a...)
+}
+func (v *Value) SetArg(i int, w *Value) {
+ v.Args[i] = w
+}
+func (v *Value) RemoveArg(i int) {
+ copy(v.Args[i:], v.Args[i+1:])
+ v.Args[len(v.Args)-1] = nil // aid GC
+ v.Args = v.Args[:len(v.Args)-1]
+}
+func (v *Value) SetArgs1(a *Value) {
+ v.resetArgs()
+ v.AddArg(a)
+}
+func (v *Value) SetArgs2(a *Value, b *Value) {
+ v.resetArgs()
+ v.AddArg(a)
+ v.AddArg(b)
+}
+
+func (v *Value) resetArgs() {
+ v.argstorage[0] = nil
+ v.argstorage[1] = nil
+ v.Args = v.argstorage[:0]
+}
+
+func (v *Value) reset(op Op) {
+ v.Op = op
+ v.resetArgs()
+ v.AuxInt = 0
+ v.Aux = nil
+}
+
+// copyInto makes a new value identical to v and adds it to the end of b.
+func (v *Value) copyInto(b *Block) *Value {
+ c := b.NewValue0(v.Line, v.Op, v.Type)
+ c.Aux = v.Aux
+ c.AuxInt = v.AuxInt
+ c.AddArgs(v.Args...)
+ for _, a := range v.Args {
+ if a.Type.IsMemory() {
+ v.Fatalf("can't move a value with a memory arg %s", v.LongString())
+ }
+ }
+ return c
+}
+
+func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) }
+func (v *Value) Log() bool { return v.Block.Log() }
+func (v *Value) Fatalf(msg string, args ...interface{}) {
+ v.Block.Func.Config.Fatalf(v.Line, msg, args...)
+}
+func (v *Value) Unimplementedf(msg string, args ...interface{}) {
+ v.Block.Func.Config.Unimplementedf(v.Line, msg, args...)
+}
+
+// ExternSymbol is an aux value that encodes a variable's
+// constant offset from the static base pointer.
+type ExternSymbol struct {
+ Typ Type // Go type
+ Sym fmt.Stringer // A *gc.Sym referring to a global variable
+ // Note: the offset for an external symbol is not
+ // calculated until link time.
+}
+
+// ArgSymbol is an aux value that encodes an argument or result
+// variable's constant offset from FP (FP = SP + framesize).
+type ArgSymbol struct {
+ Typ Type // Go type
+ Node GCNode // A *gc.Node referring to the argument/result variable.
+}
+
+// AutoSymbol is an aux value that encodes a local variable's
+// constant offset from SP.
+type AutoSymbol struct {
+ Typ Type // Go type
+ Node GCNode // A *gc.Node referring to a local (auto) variable.
+}
+
+func (s *ExternSymbol) String() string {
+ return s.Sym.String()
+}
+
+func (s *ArgSymbol) String() string {
+ return s.Node.String()
+}
+
+func (s *AutoSymbol) String() string {
+ return s.Node.String()
+}
diff --git a/src/cmd/compile/internal/ssa/zcse.go b/src/cmd/compile/internal/ssa/zcse.go
new file mode 100644
index 0000000..664fbae
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/zcse.go
@@ -0,0 +1,90 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+// zcse does an initial pass of common-subexpression elimination on the
+// function for values with zero arguments to allow the more expensive cse
+// to begin with a reduced number of values. Values are just relinked,
+// nothing is deleted. A subsequent deadcode pass is required to actually
+// remove duplicate expressions.
+func zcse(f *Func) {
+ vals := make(map[vkey]*Value)
+
+ for _, b := range f.Blocks {
+ for i := 0; i < len(b.Values); {
+ v := b.Values[i]
+ next := true
+ if opcodeTable[v.Op].argLen == 0 {
+ key := vkey{v.Op, keyFor(v), v.Aux, typeStr(v)}
+ if vals[key] == nil {
+ vals[key] = v
+ if b != f.Entry {
+ // Move v to the entry block so it will dominate every block
+ // where we might use it. This prevents the need for any dominator
+ // calculations in this pass.
+ v.Block = f.Entry
+ f.Entry.Values = append(f.Entry.Values, v)
+ last := len(b.Values) - 1
+ b.Values[i] = b.Values[last]
+ b.Values[last] = nil
+ b.Values = b.Values[:last]
+
+ // process b.Values[i] again
+ next = false
+ }
+ }
+ }
+ if next {
+ i++
+ }
+ }
+ }
+
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ for i, a := range v.Args {
+ if opcodeTable[a.Op].argLen == 0 {
+ key := vkey{a.Op, keyFor(a), a.Aux, typeStr(a)}
+ if rv, ok := vals[key]; ok {
+ v.Args[i] = rv
+ }
+ }
+ }
+ }
+ }
+}
+
+// vkey is a type used to uniquely identify a zero arg value.
+type vkey struct {
+ op Op
+ ai int64 // aux int
+ ax interface{} // aux
+ t string // type
+}
+
+// typeStr returns a string version of the type of v.
+func typeStr(v *Value) string {
+ if v.Type == nil {
+ return ""
+ }
+ return v.Type.String()
+}
+
+// keyFor returns the AuxInt portion of a key structure uniquely identifying a
+// zero arg value for the supported ops.
+func keyFor(v *Value) int64 {
+ switch v.Op {
+ case OpConst64, OpConst64F, OpConst32F:
+ return v.AuxInt
+ case OpConst32:
+ return int64(int32(v.AuxInt))
+ case OpConst16:
+ return int64(int16(v.AuxInt))
+ case OpConst8, OpConstBool:
+ return int64(int8(v.AuxInt))
+ default:
+ return v.AuxInt
+ }
+}
diff --git a/src/cmd/compile/internal/x86/prog.go b/src/cmd/compile/internal/x86/prog.go
index ccac290..3399a28 100644
--- a/src/cmd/compile/internal/x86/prog.go
+++ b/src/cmd/compile/internal/x86/prog.go
@@ -157,6 +157,7 @@
x86.AJPL: {Flags: gc.Cjmp | gc.UseCarry},
x86.AJPS: {Flags: gc.Cjmp | gc.UseCarry},
obj.AJMP: {Flags: gc.Jump | gc.Break | gc.KillCarry},
+ x86.ALEAW: {Flags: gc.LeftAddr | gc.RightWrite},
x86.ALEAL: {Flags: gc.LeftAddr | gc.RightWrite},
x86.AMOVBLSX: {Flags: gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv},
x86.AMOVBLZX: {Flags: gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv},
@@ -192,6 +193,7 @@
x86.AORW: {Flags: gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry},
x86.APOPL: {Flags: gc.SizeL | gc.RightWrite},
x86.APUSHL: {Flags: gc.SizeL | gc.LeftRead},
+ x86.APXOR: {Flags: gc.SizeD | gc.LeftRead | RightRdwr},
x86.ARCLB: {Flags: gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
x86.ARCLL: {Flags: gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
x86.ARCLW: {Flags: gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry},
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 20d9535..9b98bf2 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -36,6 +36,7 @@
"compile/internal/gc",
"compile/internal/mips64",
"compile/internal/ppc64",
+ "compile/internal/ssa",
"compile/internal/x86",
"internal/gcprog",
"internal/obj",
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index e89c141..4ae8191 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -214,14 +214,14 @@
Spadj int32
As int16
Reg int16
- RegTo2 int16 // 2nd register output operand
- Mark uint16
+ RegTo2 int16 // 2nd register output operand
+ Mark uint16 // bitmask of arch-specific items
Optab uint16
Scond uint8
Back uint8
Ft uint8
Tt uint8
- Isize uint8
+ Isize uint8 // size of the instruction in bytes (x86 only)
Mode int8
Info ProgInfo
diff --git a/src/cmd/internal/obj/obj.go b/src/cmd/internal/obj/obj.go
index 343c93a..f38078f 100644
--- a/src/cmd/internal/obj/obj.go
+++ b/src/cmd/internal/obj/obj.go
@@ -25,12 +25,13 @@
// together, so that given (only) calls Push(10, "x.go", 1) and Pop(15),
// virtual line 12 corresponds to x.go line 3.
type LineHist struct {
- Top *LineStack // current top of stack
- Ranges []LineRange // ranges for lookup
- Dir string // directory to qualify relative paths
- TrimPathPrefix string // remove leading TrimPath from recorded file names
- GOROOT string // current GOROOT
- GOROOT_FINAL string // target GOROOT
+ Top *LineStack // current top of stack
+ Ranges []LineRange // ranges for lookup
+ Dir string // directory to qualify relative paths
+ TrimPathPrefix string // remove leading TrimPath from recorded file names
+ PrintFilenameOnly bool // ignore path when pretty-printing a line; internal use only
+ GOROOT string // current GOROOT
+ GOROOT_FINAL string // target GOROOT
}
// A LineStack is an entry in the recorded line history.
@@ -221,20 +222,28 @@
return "<unknown line number>"
}
- text := fmt.Sprintf("%s:%d", stk.File, stk.fileLineAt(lineno))
+ filename := stk.File
+ if h.PrintFilenameOnly {
+ filename = filepath.Base(filename)
+ }
+ text := fmt.Sprintf("%s:%d", filename, stk.fileLineAt(lineno))
if stk.Directive && stk.Parent != nil {
stk = stk.Parent
- text += fmt.Sprintf("[%s:%d]", stk.File, stk.fileLineAt(lineno))
+ filename = stk.File
+ if h.PrintFilenameOnly {
+ filename = filepath.Base(filename)
+ }
+ text += fmt.Sprintf("[%s:%d]", filename, stk.fileLineAt(lineno))
}
const showFullStack = false // was used by old C compilers
if showFullStack {
for stk.Parent != nil {
lineno = stk.Lineno - 1
stk = stk.Parent
- text += fmt.Sprintf(" %s:%d", stk.File, stk.fileLineAt(lineno))
+ text += fmt.Sprintf(" %s:%d", filename, stk.fileLineAt(lineno))
if stk.Directive && stk.Parent != nil {
stk = stk.Parent
- text += fmt.Sprintf("[%s:%d]", stk.File, stk.fileLineAt(lineno))
+ text += fmt.Sprintf("[%s:%d]", filename, stk.fileLineAt(lineno))
}
}
}
diff --git a/src/cmd/internal/obj/pass.go b/src/cmd/internal/obj/pass.go
index ae38c41..f10fc60 100644
--- a/src/cmd/internal/obj/pass.go
+++ b/src/cmd/internal/obj/pass.go
@@ -204,7 +204,6 @@
if ctxt.Flag_optimize {
for p := sym.Text; p != nil; p = p.Link {
- p.Mark = 0 /* initialization for follow */
if p.Pcond != nil {
p.Pcond = brloop(ctxt, p.Pcond)
if p.Pcond != nil {
diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index 8ecf800..b6e6443 100644
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -406,6 +406,9 @@
if a.Index != REG_NONE {
str += fmt.Sprintf("(%v*%d)", Rconv(int(a.Index)), int(a.Scale))
}
+ if p.As == ATYPE && a.Gotype != nil {
+ str += fmt.Sprintf("%s", a.Gotype.Name)
+ }
case TYPE_CONST:
if a.Reg != 0 {
diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index dacf612..64bd865 100644
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -34,6 +34,12 @@
//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p x86
+const (
+ /* mark flags */
+ DONE = 1 << iota
+ PRESERVEFLAGS // not allowed to clobber flags
+)
+
/*
* amd64
*/
@@ -114,23 +120,23 @@
AINTO
AIRETL
AIRETW
- AJCC
- AJCS
+ AJCC // >= unsigned
+ AJCS // < unsigned
AJCXZL
- AJEQ
- AJGE
- AJGT
- AJHI
- AJLE
- AJLS
- AJLT
- AJMI
- AJNE
- AJOC
- AJOS
- AJPC
- AJPL
- AJPS
+ AJEQ // == (zero)
+ AJGE // >= signed
+ AJGT // > signed
+ AJHI // > unsigned
+ AJLE // <= signed
+ AJLS // <= unsigned
+ AJLT // < signed
+ AJMI // sign bit set (negative)
+ AJNE // != (nonzero)
+ AJOC // overflow clear
+ AJOS // overflow set
+ AJPC // parity clear
+ AJPL // sign bit clear (positive)
+ AJPS // parity set
ALAHF
ALARL
ALARW
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 1153506..9ab6615 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -1895,7 +1895,7 @@
// process forward jumps to p
for q = p.Rel; q != nil; q = q.Forwd {
- v = int32(p.Pc - (q.Pc + int64(q.Mark)))
+ v = int32(p.Pc - (q.Pc + int64(q.Isize)))
if q.Back&2 != 0 { // short
if v > 127 {
loop++
@@ -1908,7 +1908,7 @@
s.P[q.Pc+1] = byte(v)
}
} else {
- bp = s.P[q.Pc+int64(q.Mark)-4:]
+ bp = s.P[q.Pc+int64(q.Isize)-4:]
bp[0] = byte(v)
bp = bp[1:]
bp[0] = byte(v >> 8)
@@ -1931,7 +1931,6 @@
obj.Symgrow(ctxt, s, p.Pc+int64(m))
copy(s.P[p.Pc:][:m], ctxt.And[:m])
- p.Mark = uint16(m)
c += int32(m)
}
@@ -2272,8 +2271,28 @@
return Yxxx
case obj.TYPE_MEM:
- if a.Name != obj.NAME_NONE {
- if ctxt.Asmode == 64 && (a.Reg != REG_NONE || a.Index != REG_NONE || a.Scale != 0) {
+ if a.Index == REG_SP {
+ // Can't use SP as the index register
+ return Yxxx
+ }
+ if ctxt.Asmode == 64 {
+ switch a.Name {
+ case obj.NAME_EXTERN, obj.NAME_STATIC, obj.NAME_GOTREF:
+ // Global variables can't use index registers and their
+ // base register is %rip (%rip is encoded as REG_NONE).
+ if a.Reg != REG_NONE || a.Index != REG_NONE || a.Scale != 0 {
+ return Yxxx
+ }
+ case obj.NAME_AUTO, obj.NAME_PARAM:
+ // These names must have a base of SP. The old compiler
+ // uses 0 for the base register. SSA uses REG_SP.
+ if a.Reg != REG_SP && a.Reg != 0 {
+ return Yxxx
+ }
+ case obj.NAME_NONE:
+ // everything is ok
+ default:
+ // unknown name
return Yxxx
}
}
@@ -2321,6 +2340,10 @@
v = int64(int32(v))
}
if v == 0 {
+ if p.Mark&PRESERVEFLAGS != 0 {
+ // If PRESERVEFLAGS is set, avoid MOV $0, AX turning into XOR AX, AX.
+ return Yu7
+ }
return Yi0
}
if v == 1 {
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 6332b7e..3f8426a 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -38,7 +38,7 @@
"math"
)
-func canuse1insntls(ctxt *obj.Link) bool {
+func CanUse1InsnTLS(ctxt *obj.Link) bool {
if isAndroid {
// For android, we use a disgusting hack that assumes
// the thread-local storage slot for g is allocated
@@ -130,7 +130,7 @@
// rewriting the instructions more comprehensively, and it only does because
// we only support a single TLS variable (g).
- if canuse1insntls(ctxt) {
+ if CanUse1InsnTLS(ctxt) {
// Reduce 2-instruction sequence to 1-instruction sequence.
// Sequences like
// MOVQ TLS, BX
@@ -231,7 +231,8 @@
// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
case AMOVSS:
if p.From.Type == obj.TYPE_FCONST {
- if p.From.Val.(float64) == 0 {
+ // f == 0 can't be used here due to -0, so use Float64bits
+ if f := p.From.Val.(float64); math.Float64bits(f) == 0 {
if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X15 {
p.As = AXORPS
p.From = p.To
@@ -271,7 +272,8 @@
case AMOVSD:
// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
if p.From.Type == obj.TYPE_FCONST {
- if p.From.Val.(float64) == 0 {
+ // f == 0 can't be used here due to -0, so use Float64bits
+ if f := p.From.Val.(float64); math.Float64bits(f) == 0 {
if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X15 {
p.As = AXORPS
p.From = p.To
@@ -375,7 +377,7 @@
}
if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local {
// $MOV $sym, Rx becomes $MOV sym@GOT, Rx
- // $MOV $sym+<off>, Rx becomes $MOV sym@GOT, Rx; $ADD <off>, Rx
+ // $MOV $sym+<off>, Rx becomes $MOV sym@GOT, Rx; $LEA <off>(Rx), Rx
// On 386 only, more complicated things like PUSHL $sym become $MOV sym@GOT, CX; PUSHL CX
cmplxdest := false
pAs := p.As
@@ -397,8 +399,9 @@
q := p
if p.From.Offset != 0 {
q = obj.Appendp(ctxt, p)
- q.As = add
- q.From.Type = obj.TYPE_CONST
+ q.As = lea
+ q.From.Type = obj.TYPE_MEM
+ q.From.Reg = p.To.Reg
q.From.Offset = p.From.Offset
q.To = p.To
p.From.Offset = 0
@@ -1212,16 +1215,16 @@
q = p.Pcond
if q != nil && q.As != obj.ATEXT {
/* mark instruction as done and continue layout at target of jump */
- p.Mark = 1
+ p.Mark |= DONE
p = q
- if p.Mark == 0 {
+ if p.Mark&DONE == 0 {
goto loop
}
}
}
- if p.Mark != 0 {
+ if p.Mark&DONE != 0 {
/*
* p goes here, but already used it elsewhere.
* copy up to 4 instructions or else branch to other copy.
@@ -1244,7 +1247,7 @@
if nofollow(a) || pushpop(a) {
break // NOTE(rsc): arm does goto copy
}
- if q.Pcond == nil || q.Pcond.Mark != 0 {
+ if q.Pcond == nil || q.Pcond.Mark&DONE != 0 {
continue
}
if a == obj.ACALL || a == ALOOP {
@@ -1258,10 +1261,10 @@
q = obj.Copyp(ctxt, p)
p = p.Link
- q.Mark = 1
+ q.Mark |= DONE
(*last).Link = q
*last = q
- if int(q.As) != a || q.Pcond == nil || q.Pcond.Mark != 0 {
+ if int(q.As) != a || q.Pcond == nil || q.Pcond.Mark&DONE != 0 {
continue
}
@@ -1271,7 +1274,7 @@
q.Link = p
xfol(ctxt, q.Link, last)
p = q.Link
- if p.Mark != 0 {
+ if p.Mark&DONE != 0 {
return
}
goto loop
@@ -1288,7 +1291,7 @@
}
/* emit p */
- p.Mark = 1
+ p.Mark |= DONE
(*last).Link = p
*last = p
@@ -1326,7 +1329,7 @@
}
} else {
q = p.Link
- if q.Mark != 0 {
+ if q.Mark&DONE != 0 {
if a != ALOOP {
p.As = relinv(int16(a))
p.Link = p.Pcond
@@ -1336,7 +1339,7 @@
}
xfol(ctxt, p.Link, last)
- if p.Pcond.Mark != 0 {
+ if p.Pcond.Mark&DONE != 0 {
return
}
p = p.Pcond
diff --git a/src/cmd/internal/obj/x86/obj6_test.go b/src/cmd/internal/obj/x86/obj6_test.go
index 5fa1d3b..a5c80ce 100644
--- a/src/cmd/internal/obj/x86/obj6_test.go
+++ b/src/cmd/internal/obj/x86/obj6_test.go
@@ -20,9 +20,9 @@
MOVQ AX, AX -> MOVQ AX, AX
LEAQ name(SB), AX -> MOVQ name@GOT(SB), AX
-LEAQ name+10(SB), AX -> MOVQ name@GOT(SB), AX; ADDQ $10, AX
+LEAQ name+10(SB), AX -> MOVQ name@GOT(SB), AX; LEAQ 10(AX), AX
MOVQ $name(SB), AX -> MOVQ name@GOT(SB), AX
-MOVQ $name+10(SB), AX -> MOVQ name@GOT(SB), AX; ADDQ $10, AX
+MOVQ $name+10(SB), AX -> MOVQ name@GOT(SB), AX; LEAQ 10(AX), AX
MOVQ name(SB), AX -> NOP; MOVQ name@GOT(SB), R15; MOVQ (R15), AX
MOVQ name+10(SB), AX -> NOP; MOVQ name@GOT(SB), R15; MOVQ 10(R15), AX
diff --git a/src/crypto/x509/sec1_test.go b/src/crypto/x509/sec1_test.go
index 5e9ded5..55b76d6 100644
--- a/src/crypto/x509/sec1_test.go
+++ b/src/crypto/x509/sec1_test.go
@@ -10,8 +10,8 @@
"testing"
)
-var ecKeyTests = []struct{
- derHex string
+var ecKeyTests = []struct {
+ derHex string
shouldReserialize bool
}{
// Generated using:
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index df8b453..138a623 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -216,9 +216,10 @@
// The compiler knows about this variable.
// If you change it, you must change the compiler too.
var writeBarrier struct {
- enabled bool // compiler emits a check of this before calling write barrier
- needed bool // whether we need a write barrier for current GC phase
- cgo bool // whether we need a write barrier for a cgo check
+ enabled bool // compiler emits a check of this before calling write barrier
+ needed bool // whether we need a write barrier for current GC phase
+ cgo bool // whether we need a write barrier for a cgo check
+ alignme uint64 // guarantee alignment so that compiler can use a 32 or 64-bit load
}
// gcBlackenEnabled is 1 if mutator assists and background mark
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index d9e674b..80c4d79 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -159,14 +159,28 @@
ret:
RET
+// func runtime·racefuncenterfp(fp uintptr)
+// Called from instrumented code.
+// Like racefuncenter but passes FP, not PC
+TEXT runtime·racefuncenterfp(SB), NOSPLIT, $0-8
+ MOVQ fp+0(FP), R11
+ MOVQ -8(R11), R11
+ JMP racefuncenter<>(SB)
+
// func runtime·racefuncenter(pc uintptr)
// Called from instrumented code.
TEXT runtime·racefuncenter(SB), NOSPLIT, $0-8
+ MOVQ callpc+0(FP), R11
+ JMP racefuncenter<>(SB)
+
+// Common code for racefuncenter/racefuncenterfp
+// R11 = caller's return address
+TEXT racefuncenter<>(SB), NOSPLIT, $0-0
MOVQ DX, R15 // save function entry context (for closures)
get_tls(R12)
MOVQ g(R12), R14
MOVQ g_racectx(R14), RARG0 // goroutine context
- MOVQ callpc+0(FP), RARG1
+ MOVQ R11, RARG1
// void __tsan_func_enter(ThreadState *thr, void *pc);
MOVQ $__tsan_func_enter(SB), AX
// racecall<> preserves R15
diff --git a/src/runtime/runtime-gdb_test.go b/src/runtime/runtime-gdb_test.go
index 6ebc69a..110d990 100644
--- a/src/runtime/runtime-gdb_test.go
+++ b/src/runtime/runtime-gdb_test.go
@@ -98,9 +98,6 @@
"-ex", "echo END\n",
"-ex", "echo BEGIN print strvar\n",
"-ex", "print strvar",
- "-ex", "echo END\n",
- "-ex", "echo BEGIN print ptrvar\n",
- "-ex", "print ptrvar",
"-ex", "echo END\n"}
// without framepointer, gdb cannot backtrace our non-standard
@@ -158,10 +155,6 @@
t.Fatalf("print strvar failed: %s", bl)
}
- if bl := blocks["print ptrvar"]; !strVarRe.MatchString(bl) {
- t.Fatalf("print ptrvar failed: %s", bl)
- }
-
btGoroutineRe := regexp.MustCompile(`^#0\s+runtime.+at`)
if bl := blocks["goroutine 2 bt"]; canBackTrace && !btGoroutineRe.MatchString(bl) {
t.Fatalf("goroutine 2 bt failed: %s", bl)
diff --git a/test/fixedbugs/issue12347.go b/test/fixedbugs/issue12347.go
new file mode 100644
index 0000000..4bbe09c
--- /dev/null
+++ b/test/fixedbugs/issue12347.go
@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+func f_ssa(x int, p *int) {
+ if false {
+ y := x + 5
+ for {
+ *p = y
+ }
+ }
+}
diff --git a/test/goto.go b/test/goto.go
index ca477b3..2daaa95 100644
--- a/test/goto.go
+++ b/test/goto.go
@@ -40,7 +40,7 @@
// goto across declaration not okay
func _() {
goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
- x := 1 // GCCGO_ERROR "defined here"
+ x := 1 // GCCGO_ERROR "defined here"
_ = x
L:
}
@@ -62,7 +62,7 @@
x := 1
_ = x
}
- x := 1 // GCCGO_ERROR "defined here"
+ x := 1 // GCCGO_ERROR "defined here"
_ = x
L:
}
@@ -78,7 +78,7 @@
// error shows first offending variable
func _() {
goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
- x := 1 // GCCGO_ERROR "defined here"
+ x := 1 // GCCGO_ERROR "defined here"
_ = x
y := 1
_ = y
@@ -88,7 +88,7 @@
// goto not okay even if code path is dead
func _() {
goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
- x := 1 // GCCGO_ERROR "defined here"
+ x := 1 // GCCGO_ERROR "defined here"
_ = x
y := 1
_ = y
@@ -115,14 +115,14 @@
// goto into inner block not okay
func _() {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- { // GCCGO_ERROR "block starts here"
+ { // GCCGO_ERROR "block starts here"
L:
}
}
// goto backward into inner block still not okay
func _() {
- { // GCCGO_ERROR "block starts here"
+ { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
@@ -133,7 +133,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
{
{
- { // GCCGO_ERROR "block starts here"
+ { // GCCGO_ERROR "block starts here"
L:
}
}
@@ -145,7 +145,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+3|goto jumps into block"
x := 1
_ = x
- { // GCCGO_ERROR "block starts here"
+ { // GCCGO_ERROR "block starts here"
L:
}
}
@@ -179,15 +179,15 @@
}
func _() {
- goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- if true { // GCCGO_ERROR "block starts here"
+ goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+ if true { // GCCGO_ERROR "block starts here"
L:
}
}
func _() {
- goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- if true { // GCCGO_ERROR "block starts here"
+ goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+ if true { // GCCGO_ERROR "block starts here"
L:
} else {
}
@@ -196,13 +196,13 @@
func _() {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
if true {
- } else { // GCCGO_ERROR "block starts here"
+ } else { // GCCGO_ERROR "block starts here"
L:
}
}
func _() {
- if false { // GCCGO_ERROR "block starts here"
+ if false { // GCCGO_ERROR "block starts here"
L:
} else {
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
@@ -212,7 +212,7 @@
func _() {
if true {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- } else { // GCCGO_ERROR "block starts here"
+ } else { // GCCGO_ERROR "block starts here"
L:
}
}
@@ -220,7 +220,7 @@
func _() {
if true {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- } else if false { // GCCGO_ERROR "block starts here"
+ } else if false { // GCCGO_ERROR "block starts here"
L:
}
}
@@ -228,7 +228,7 @@
func _() {
if true {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
- } else if false { // GCCGO_ERROR "block starts here"
+ } else if false { // GCCGO_ERROR "block starts here"
L:
} else {
}
@@ -243,7 +243,7 @@
if true {
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
} else if false {
- } else { // GCCGO_ERROR "block starts here"
+ } else { // GCCGO_ERROR "block starts here"
L:
}
}
@@ -287,14 +287,14 @@
}
func _() {
- for { // GCCGO_ERROR "block starts here"
+ for { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for { // GCCGO_ERROR "block starts here"
+ for { // GCCGO_ERROR "block starts here"
goto L
L1:
}
@@ -303,42 +303,42 @@
}
func _() {
- for i < n { // GCCGO_ERROR "block starts here"
+ for i < n { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for i = 0; i < n; i++ { // GCCGO_ERROR "block starts here"
+ for i = 0; i < n; i++ { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for i = range x { // GCCGO_ERROR "block starts here"
+ for i = range x { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for i = range c { // GCCGO_ERROR "block starts here"
+ for i = range c { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for i = range m { // GCCGO_ERROR "block starts here"
+ for i = range m { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
}
func _() {
- for i = range s { // GCCGO_ERROR "block starts here"
+ for i = range s { // GCCGO_ERROR "block starts here"
L:
}
goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
@@ -398,7 +398,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
switch i {
case 0:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
@@ -406,7 +406,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
switch i {
case 0:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
;
default:
}
@@ -417,7 +417,7 @@
switch i {
case 0:
default:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
@@ -426,14 +426,14 @@
default:
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
case 0:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
func _() {
switch i {
case 0:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
;
default:
goto L // ERROR "goto L jumps into block starting at LINE-4|goto jumps into block"
@@ -495,7 +495,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+2|goto jumps into block"
select {
case c <- 1:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
@@ -503,7 +503,7 @@
goto L // ERROR "goto L jumps into block starting at LINE+2|goto jumps into block"
select {
case c <- 1:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
;
default:
}
@@ -514,7 +514,7 @@
select {
case <-c:
default:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
@@ -523,14 +523,14 @@
default:
goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
case <-c:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
}
}
func _() {
select {
case <-c:
- L: // GCCGO_ERROR "block starts here"
+ L: // GCCGO_ERROR "block starts here"
;
default:
goto L // ERROR "goto L jumps into block starting at LINE-4|goto jumps into block"
diff --git a/test/label.go b/test/label.go
index b30c27e..c3c0c27 100644
--- a/test/label.go
+++ b/test/label.go
@@ -17,8 +17,7 @@
for {
}
L2: // ERROR "label .*L2.* defined and not used"
- select {
- }
+ select {}
L3: // ERROR "label .*L3.* defined and not used"
switch {
}
@@ -59,4 +58,8 @@
default:
break L10
}
+
+ goto L10
+
+ goto go2 // ERROR "label go2 not defined"
}
diff --git a/test/label1.go b/test/label1.go
index f923a18..937b5cb90 100644
--- a/test/label1.go
+++ b/test/label1.go
@@ -4,7 +4,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-
// Verify that erroneous labels are caught by the compiler.
// This set is caught by pass 2. That's why this file is label1.go.
// Does not compile.
@@ -32,11 +31,17 @@
break L2
}
if x == 1 {
- continue L2 // ERROR "invalid continue label .*L2"
+ continue L2 // ERROR "invalid continue label .*L2|continue is not in a loop"
}
goto L2
}
+ for {
+ if x == 1 {
+ continue L2 // ERROR "invalid continue label .*L2"
+ }
+ }
+
L3:
switch {
case x > 10:
@@ -44,7 +49,7 @@
break L3
}
if x == 12 {
- continue L3 // ERROR "invalid continue label .*L3"
+ continue L3 // ERROR "invalid continue label .*L3|continue is not in a loop"
}
goto L3
}
@@ -55,7 +60,7 @@
break L4 // ERROR "invalid break label .*L4"
}
if x == 14 {
- continue L4 // ERROR "invalid continue label .*L4"
+ continue L4 // ERROR "invalid continue label .*L4|continue is not in a loop"
}
if x == 15 {
goto L4
@@ -68,7 +73,7 @@
break L5 // ERROR "invalid break label .*L5"
}
if x == 17 {
- continue L5 // ERROR "invalid continue label .*L5"
+ continue L5 // ERROR "invalid continue label .*L5|continue is not in a loop"
}
if x == 18 {
goto L5
@@ -85,4 +90,21 @@
goto L1
}
}
+
+ continue // ERROR "continue is not in a loop"
+ for {
+ continue on // ERROR "continue label not defined: on"
+ }
+
+ break // ERROR "break is not in a loop"
+ for {
+ break dance // ERROR "break label not defined: dance"
+ }
+
+ for {
+ switch x {
+ case 1:
+ continue
+ }
+ }
}
diff --git a/test/live.go b/test/live.go
index ae982f4..c54f091 100644
--- a/test/live.go
+++ b/test/live.go
@@ -1,3 +1,4 @@
+// +build !amd64
// errorcheck -0 -l -live -wb=0
// Copyright 2014 The Go Authors. All rights reserved.
diff --git a/test/live2.go b/test/live2.go
index 7474756..430f9fe 100644
--- a/test/live2.go
+++ b/test/live2.go
@@ -1,3 +1,4 @@
+// +build !amd64
// errorcheck -0 -live -wb=0
// Copyright 2014 The Go Authors. All rights reserved.
diff --git a/test/nilcheck.go b/test/nilcheck.go
index 99c3c5f..ab28b33 100644
--- a/test/nilcheck.go
+++ b/test/nilcheck.go
@@ -17,7 +17,7 @@
type BigStruct struct {
X int
Y float64
- A [1<<20]int
+ A [1 << 20]int
Z string
}
@@ -29,86 +29,86 @@
}
var (
- intp *int
- arrayp *[10]int
- array0p *[0]int
- bigarrayp *[1<<26]int
- structp *Struct
+ intp *int
+ arrayp *[10]int
+ array0p *[0]int
+ bigarrayp *[1 << 26]int
+ structp *Struct
bigstructp *BigStruct
- emptyp *Empty
- empty1p *Empty1
+ emptyp *Empty
+ empty1p *Empty1
)
func f1() {
- _ = *intp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
+ _ = *intp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
_ = *array0p // ERROR "nil check"
_ = *array0p // ERROR "nil check"
- _ = *intp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
+ _ = *intp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
_ = *structp // ERROR "nil check"
- _ = *emptyp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
+ _ = *emptyp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
}
func f2() {
var (
- intp *int
- arrayp *[10]int
- array0p *[0]int
- bigarrayp *[1<<20]int
- structp *Struct
+ intp *int
+ arrayp *[10]int
+ array0p *[0]int
+ bigarrayp *[1 << 20]int
+ structp *Struct
bigstructp *BigStruct
- emptyp *Empty
- empty1p *Empty1
+ emptyp *Empty
+ empty1p *Empty1
)
- _ = *intp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
- _ = *array0p // ERROR "nil check"
- _ = *array0p // ERROR "nil check"
- _ = *intp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
- _ = *structp // ERROR "nil check"
- _ = *emptyp // ERROR "nil check"
- _ = *arrayp // ERROR "nil check"
- _ = *bigarrayp // ERROR "nil check"
+ _ = *intp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
+ _ = *array0p // ERROR "nil check"
+ _ = *array0p // ERROR "nil check"
+ _ = *intp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
+ _ = *structp // ERROR "nil check"
+ _ = *emptyp // ERROR "nil check"
+ _ = *arrayp // ERROR "nil check"
+ _ = *bigarrayp // ERROR "nil check"
_ = *bigstructp // ERROR "nil check"
- _ = *empty1p // ERROR "nil check"
+ _ = *empty1p // ERROR "nil check"
}
func fx10k() *[10000]int
-var b bool
+var b bool
func f3(x *[10000]int) {
// Using a huge type and huge offsets so the compiler
// does not expect the memory hardware to fault.
_ = x[9999] // ERROR "nil check"
-
+
for {
if x[9999] != 0 { // ERROR "nil check"
break
}
}
-
- x = fx10k()
+
+ x = fx10k()
_ = x[9999] // ERROR "nil check"
if b {
_ = x[9999] // ERROR "nil check"
} else {
_ = x[9999] // ERROR "nil check"
- }
+ }
_ = x[9999] // ERROR "nil check"
- x = fx10k()
+ x = fx10k()
if b {
_ = x[9999] // ERROR "nil check"
} else {
_ = x[9999] // ERROR "nil check"
- }
+ }
_ = x[9999] // ERROR "nil check"
-
+
fx10k()
// This one is a bit redundant, if we figured out that
// x wasn't going to change across the function call.
@@ -138,7 +138,7 @@
_ = &x[9] // ERROR "nil check"
}
-func fx10() *[10]int
+func fx10() *[10]int
func f4(x *[10]int) {
// Most of these have no checks because a real memory reference follows,
@@ -146,33 +146,33 @@
// in the first unmapped page of memory.
_ = x[9] // ERROR "nil check"
-
+
for {
if x[9] != 0 { // ERROR "nil check"
break
}
}
-
- x = fx10()
+
+ x = fx10()
_ = x[9] // ERROR "nil check"
if b {
_ = x[9] // ERROR "nil check"
} else {
_ = x[9] // ERROR "nil check"
- }
+ }
_ = x[9] // ERROR "nil check"
- x = fx10()
+ x = fx10()
if b {
_ = x[9] // ERROR "nil check"
} else {
_ = &x[9] // ERROR "nil check"
- }
+ }
_ = x[9] // ERROR "nil check"
-
+
fx10()
_ = x[9] // ERROR "nil check"
-
+
x = fx10()
y := fx10()
_ = &x[9] // ERROR "nil check"
diff --git a/test/nilptr3.go b/test/nilptr3.go
index 6c8aab3..1ba774d 100644
--- a/test/nilptr3.go
+++ b/test/nilptr3.go
@@ -2,7 +2,7 @@
// Fails on ppc64x because of incomplete optimization.
// See issues 9058.
// Same reason for mips64x.
-// +build !ppc64,!ppc64le,!mips64,!mips64le
+// +build !ppc64,!ppc64le,!mips64,!mips64le,!amd64
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
diff --git a/test/nilptr3_ssa.go b/test/nilptr3_ssa.go
new file mode 100644
index 0000000..ba60a64
--- /dev/null
+++ b/test/nilptr3_ssa.go
@@ -0,0 +1,209 @@
+// errorcheck -0 -d=nil
+// Fails on ppc64x because of incomplete optimization.
+// See issues 9058.
+// +build !ppc64,!ppc64le,amd64
+
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that nil checks are removed.
+// Optimization is enabled.
+
+package p
+
+type Struct struct {
+ X int
+ Y float64
+}
+
+type BigStruct struct {
+ X int
+ Y float64
+ A [1 << 20]int
+ Z string
+}
+
+type Empty struct {
+}
+
+type Empty1 struct {
+ Empty
+}
+
+var (
+ intp *int
+ arrayp *[10]int
+ array0p *[0]int
+ bigarrayp *[1 << 26]int
+ structp *Struct
+ bigstructp *BigStruct
+ emptyp *Empty
+ empty1p *Empty1
+)
+
+func f1() {
+ _ = *intp // ERROR "generated nil check"
+
+ // This one should be removed but the block copy needs
+ // to be turned into its own pseudo-op in order to see
+ // the indirect.
+ _ = *arrayp // ERROR "generated nil check"
+
+ // 0-byte indirect doesn't suffice.
+ // we don't registerize globals, so there are no removed.* nil checks.
+ _ = *array0p // ERROR "generated nil check"
+ _ = *array0p // ERROR "removed nil check"
+
+ _ = *intp // ERROR "removed nil check"
+ _ = *arrayp // ERROR "removed nil check"
+ _ = *structp // ERROR "generated nil check"
+ _ = *emptyp // ERROR "generated nil check"
+ _ = *arrayp // ERROR "removed nil check"
+}
+
+func f2() {
+ var (
+ intp *int
+ arrayp *[10]int
+ array0p *[0]int
+ bigarrayp *[1 << 20]int
+ structp *Struct
+ bigstructp *BigStruct
+ emptyp *Empty
+ empty1p *Empty1
+ )
+
+ _ = *intp // ERROR "generated nil check"
+ _ = *arrayp // ERROR "generated nil check"
+ _ = *array0p // ERROR "generated nil check"
+ _ = *array0p // ERROR "removed.* nil check"
+ _ = *intp // ERROR "removed.* nil check"
+ _ = *arrayp // ERROR "removed.* nil check"
+ _ = *structp // ERROR "generated nil check"
+ _ = *emptyp // ERROR "generated nil check"
+ _ = *arrayp // ERROR "removed.* nil check"
+ _ = *bigarrayp // ERROR "generated nil check" ARM removed nil check before indirect!!
+ _ = *bigstructp // ERROR "generated nil check"
+ _ = *empty1p // ERROR "generated nil check"
+}
+
+func fx10k() *[10000]int
+
+var b bool
+
+func f3(x *[10000]int) {
+ // Using a huge type and huge offsets so the compiler
+ // does not expect the memory hardware to fault.
+ _ = x[9999] // ERROR "generated nil check"
+
+ for {
+ if x[9999] != 0 { // ERROR "removed nil check"
+ break
+ }
+ }
+
+ x = fx10k()
+ _ = x[9999] // ERROR "generated nil check"
+ if b {
+ _ = x[9999] // ERROR "removed.* nil check"
+ } else {
+ _ = x[9999] // ERROR "removed.* nil check"
+ }
+ _ = x[9999] // ERROR "removed nil check"
+
+ x = fx10k()
+ if b {
+ _ = x[9999] // ERROR "generated nil check"
+ } else {
+ _ = x[9999] // ERROR "generated nil check"
+ }
+ _ = x[9999] // ERROR "generated nil check"
+
+ fx10k()
+ // This one is a bit redundant, if we figured out that
+ // x wasn't going to change across the function call.
+ // But it's a little complex to do and in practice doesn't
+ // matter enough.
+ _ = x[9999] // ERROR "removed nil check"
+}
+
+func f3a() {
+ x := fx10k()
+ y := fx10k()
+ z := fx10k()
+ _ = &x[9] // ERROR "generated nil check"
+ y = z
+ _ = &x[9] // ERROR "removed.* nil check"
+ x = y
+ _ = &x[9] // ERROR "generated nil check"
+}
+
+func f3b() {
+ x := fx10k()
+ y := fx10k()
+ _ = &x[9] // ERROR "generated nil check"
+ y = x
+ _ = &x[9] // ERROR "removed.* nil check"
+ x = y
+ _ = &x[9] // ERROR "removed.* nil check"
+}
+
+func fx10() *[10]int
+
+func f4(x *[10]int) {
+ // Most of these have no checks because a real memory reference follows,
+ // and the offset is small enough that if x is nil, the address will still be
+ // in the first unmapped page of memory.
+
+ _ = x[9] // ERROR "removed nil check"
+
+ for {
+ if x[9] != 0 { // ERROR "removed nil check"
+ break
+ }
+ }
+
+ x = fx10()
+ _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect
+ if b {
+ _ = x[9] // ERROR "removed nil check"
+ } else {
+ _ = x[9] // ERROR "removed nil check"
+ }
+ _ = x[9] // ERROR "removed nil check"
+
+ x = fx10()
+ if b {
+ _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect
+ } else {
+ _ = &x[9] // ERROR "generated nil check"
+ }
+ _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect
+
+ fx10()
+ _ = x[9] // ERROR "removed nil check"
+
+ x = fx10()
+ y := fx10()
+ _ = &x[9] // ERROR "generated nil check"
+ y = x
+ _ = &x[9] // ERROR "removed[a-z ]* nil check"
+ x = y
+ _ = &x[9] // ERROR "removed[a-z ]* nil check"
+}
+
+func f5(p *float32, q *float64, r *float32, s *float64) float64 {
+ x := float64(*p) // ERROR "removed nil check"
+ y := *q // ERROR "removed nil check"
+ *r = 7 // ERROR "removed nil check"
+ *s = 9 // ERROR "removed nil check"
+ return x + y
+}
+
+type T [29]byte
+
+func f6(p, q *T) {
+ x := *p // ERROR "removed nil check"
+ *q = x // ERROR "removed nil check"
+}
diff --git a/test/nosplit.go b/test/nosplit.go
index 3c4ae10..082fc3b 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -302,9 +302,10 @@
// Instead of rewriting the test cases above, adjust
// the first stack frame to use up the extra bytes.
if i == 0 {
- size += 592 - 128
+ size += (720 - 128) - 128
// Noopt builds have a larger stackguard.
- // See ../cmd/dist/buildruntime.go:stackGuardMultiplier
+ // See ../src/cmd/dist/buildruntime.go:stackGuardMultiplier
+ // This increase is included in obj.StackGuard
for _, s := range strings.Split(os.Getenv("GO_GCFLAGS"), " ") {
if s == "-N" {
size += 720
diff --git a/test/opt_branchlikely.go b/test/opt_branchlikely.go
new file mode 100644
index 0000000..99e9146
--- /dev/null
+++ b/test/opt_branchlikely.go
@@ -0,0 +1,85 @@
+// +build amd64
+// errorcheck -0 -d=ssa/likelyadjust/debug=1
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that branches have some prediction properties.
+package foo
+
+func f(x, y, z int) int {
+ a := 0
+ for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop"
+ for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop"
+ a += j
+ }
+ for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop"
+ a -= x + y + z
+ }
+ }
+ return a
+}
+
+func g(x, y, z int) int {
+ a := 0
+ if y == 0 { // ERROR "Branch prediction rule default < call"
+ y = g(y, z, x)
+ } else {
+ y++
+ }
+ if y == x { // ERROR "Branch prediction rule default < call"
+ y = g(y, z, x)
+ } else {
+ }
+ if y == 2 { // ERROR "Branch prediction rule default < call"
+ z++
+ } else {
+ y = g(z, x, y)
+ }
+ if y+z == 3 { // ERROR "Branch prediction rule call < exit"
+ println("ha ha")
+ } else {
+ panic("help help help")
+ }
+ if x != 0 { // ERROR "Branch prediction rule default < ret"
+ for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop"
+ if x == 4 { // ERROR "Branch prediction rule stay in loop"
+ return a
+ }
+ for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop"
+ for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop"
+ a -= j * i
+ }
+ a += j
+ }
+ }
+ }
+ return a
+}
+
+func h(x, y, z int) int {
+ a := 0
+ for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop"
+ for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop"
+ a += j
+ if i == j { // ERROR "Branch prediction rule stay in loop"
+ break
+ }
+ a *= j
+ }
+ for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop"
+ a -= k
+ if i == k {
+ continue
+ }
+ a *= k
+ }
+ }
+ if a > 0 { // ERROR "Branch prediction rule default < call"
+ a = g(x, y, z)
+ } else {
+ a = -a
+ }
+ return a
+}
diff --git a/test/phiopt.go b/test/phiopt.go
new file mode 100644
index 0000000..9b9b701
--- /dev/null
+++ b/test/phiopt.go
@@ -0,0 +1,43 @@
+// +build amd64
+// errorcheck -0 -d=ssa/phiopt/debug=3
+
+package main
+
+func f0(a bool) bool {
+ x := false
+ if a {
+ x = true
+ } else {
+ x = false
+ }
+ return x // ERROR "converted OpPhi to OpCopy$"
+}
+
+func f1(a bool) bool {
+ x := false
+ if a {
+ x = false
+ } else {
+ x = true
+ }
+ return x // ERROR "converted OpPhi to OpNot$"
+}
+
+func f2(a, b int) bool {
+ x := true
+ if a == b {
+ x = false
+ }
+ return x // ERROR "converted OpPhi to OpNot$"
+}
+
+func f3(a, b int) bool {
+ x := false
+ if a == b {
+ x = true
+ }
+ return x // ERROR "converted OpPhi to OpCopy$"
+}
+
+func main() {
+}
diff --git a/test/prove.go b/test/prove.go
new file mode 100644
index 0000000..0f5b8ce
--- /dev/null
+++ b/test/prove.go
@@ -0,0 +1,207 @@
+// +build amd64
+// errorcheck -0 -d=ssa/prove/debug=3
+
+package main
+
+func f0(a []int) int {
+ a[0] = 1
+ a[0] = 1 // ERROR "Proved IsInBounds$"
+ a[6] = 1
+ a[6] = 1 // ERROR "Proved IsInBounds$"
+ a[5] = 1
+ a[5] = 1 // ERROR "Proved IsInBounds$"
+ return 13
+}
+
+func f1(a []int) int {
+ if len(a) <= 5 {
+ return 18
+ }
+ a[0] = 1
+ a[0] = 1 // ERROR "Proved IsInBounds$"
+ a[6] = 1
+ a[6] = 1 // ERROR "Proved IsInBounds$"
+ a[5] = 1 // ERROR "Proved constant IsInBounds$"
+ a[5] = 1 // ERROR "Proved IsInBounds$"
+ return 26
+}
+
+func f2(a []int) int {
+ for i := range a {
+ a[i] = i
+ a[i] = i // ERROR "Proved IsInBounds$"
+ }
+ return 34
+}
+
+func f3(a []uint) int {
+ for i := uint(0); i < uint(len(a)); i++ {
+ a[i] = i // ERROR "Proved IsInBounds$"
+ }
+ return 41
+}
+
+func f4a(a, b, c int) int {
+ if a < b {
+ if a == b { // ERROR "Disproved Eq64$"
+ return 47
+ }
+ if a > b { // ERROR "Disproved Greater64$"
+ return 50
+ }
+ if a < b { // ERROR "Proved Less64$"
+ return 53
+ }
+ if a == b { // ERROR "Disproved Eq64$"
+ return 56
+ }
+ if a > b {
+ return 59
+ }
+ return 61
+ }
+ return 63
+}
+
+func f4b(a, b, c int) int {
+ if a <= b {
+ if a >= b {
+ if a == b { // ERROR "Proved Eq64$"
+ return 70
+ }
+ return 75
+ }
+ return 77
+ }
+ return 79
+}
+
+func f4c(a, b, c int) int {
+ if a <= b {
+ if a >= b {
+ if a != b { // ERROR "Disproved Neq64$"
+ return 73
+ }
+ return 75
+ }
+ return 77
+ }
+ return 79
+}
+
+func f4d(a, b, c int) int {
+ if a < b {
+ if a < c {
+ if a < b { // ERROR "Proved Less64$"
+ if a < c { // ERROR "Proved Less64$"
+ return 87
+ }
+ return 89
+ }
+ return 91
+ }
+ return 93
+ }
+ return 95
+}
+
+func f4e(a, b, c int) int {
+ if a < b {
+ if b > a { // ERROR "Proved Greater64$"
+ return 101
+ }
+ return 103
+ }
+ return 105
+}
+
+func f4f(a, b, c int) int {
+ if a <= b {
+ if b > a {
+ if b == a { // ERROR "Disproved Eq64$"
+ return 112
+ }
+ return 114
+ }
+ if b >= a { // ERROR "Proved Geq64$"
+ if b == a { // ERROR "Proved Eq64$"
+ return 118
+ }
+ return 120
+ }
+ return 122
+ }
+ return 124
+}
+
+func f5(a, b uint) int {
+ if a == b {
+ if a <= b { // ERROR "Proved Leq64U$"
+ return 130
+ }
+ return 132
+ }
+ return 134
+}
+
+// These comparisons are compile time constants.
+func f6a(a uint8) int {
+ if a < a { // ERROR "Disproved Less8U$"
+ return 140
+ }
+ return 151
+}
+
+func f6b(a uint8) int {
+ if a < a { // ERROR "Disproved Less8U$"
+ return 140
+ }
+ return 151
+}
+
+func f6x(a uint8) int {
+ if a > a { // ERROR "Disproved Greater8U$"
+ return 143
+ }
+ return 151
+}
+
+func f6d(a uint8) int {
+ if a <= a { // ERROR "Proved Leq8U$"
+ return 146
+ }
+ return 151
+}
+
+func f6e(a uint8) int {
+ if a >= a { // ERROR "Proved Geq8U$"
+ return 149
+ }
+ return 151
+}
+
+func f7(a []int, b int) int {
+ if b < len(a) {
+ a[b] = 3
+ if b < len(a) { // ERROR "Proved Less64$"
+ a[b] = 5 // ERROR "Proved IsInBounds$"
+ }
+ }
+ return 161
+}
+
+func f8(a, b uint) int {
+ if a == b {
+ return 166
+ }
+ if a > b {
+ return 169
+ }
+ if a < b { // ERROR "Proved Less64U$"
+ return 172
+ }
+ return 174
+}
+
+func main() {
+}
diff --git a/test/run.go b/test/run.go
index 52230ef..8e68779 100644
--- a/test/run.go
+++ b/test/run.go
@@ -37,6 +37,7 @@
numParallel = flag.Int("n", runtime.NumCPU(), "number of parallel tests to run")
summary = flag.Bool("summary", false, "show summary of results")
showSkips = flag.Bool("show_skips", false, "show skipped tests")
+ runSkips = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)")
linkshared = flag.Bool("linkshared", false, "")
updateErrors = flag.Bool("update_errors", false, "update error messages in test file based on compiler output")
runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run")
@@ -339,6 +340,9 @@
// shouldTest looks for build tags in a source file and returns
// whether the file should be used according to the tags.
func shouldTest(src string, goos, goarch string) (ok bool, whyNot string) {
+ if *runSkips {
+ return true, ""
+ }
for _, line := range strings.Split(src, "\n") {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, "//") {
@@ -485,6 +489,9 @@
args = args[1:]
}
case "skip":
+ if *runSkips {
+ break
+ }
t.action = "skip"
return
default:
@@ -508,6 +515,7 @@
}
useTmp := true
+ ssaMain := false
runcmd := func(args ...string) ([]byte, error) {
cmd := exec.Command(args[0], args[1:]...)
var buf bytes.Buffer
@@ -516,6 +524,11 @@
if useTmp {
cmd.Dir = t.tempDir
cmd.Env = envForDir(cmd.Dir)
+ } else {
+ cmd.Env = os.Environ()
+ }
+ if ssaMain && os.Getenv("GOARCH") == "amd64" {
+ cmd.Env = append(cmd.Env, "GOSSAPKG=main")
}
err := cmd.Run()
if err != nil {
@@ -647,6 +660,7 @@
case "run":
useTmp = false
+ ssaMain = true
cmd := []string{"go", "run"}
if *linkshared {
cmd = append(cmd, "-linkshared")
@@ -682,6 +696,7 @@
t.err = fmt.Errorf("write tempfile:%s", err)
return
}
+ ssaMain = true
cmd = []string{"go", "run"}
if *linkshared {
cmd = append(cmd, "-linkshared")
diff --git a/test/sliceopt.go b/test/sliceopt.go
index c9d089f..90ec750 100644
--- a/test/sliceopt.go
+++ b/test/sliceopt.go
@@ -1,3 +1,4 @@
+// +build !amd64
// errorcheck -0 -d=append,slice
// Copyright 2015 The Go Authors. All rights reserved.
